code
stringlengths
86
54.5k
code_codestyle
int64
0
371
style_context
stringlengths
87
49.2k
style_context_codestyle
int64
0
349
label
int64
0
1
"""simple docstring""" import os from pickle import UnpicklingError from typing import Dict, Tuple import jax import jax.numpy as jnp import numpy as np from flax.serialization import from_bytes from flax.traverse_util import flatten_dict, unflatten_dict import transformers from .utils import logging UpperCAmelCase_ : Dict = logging.get_logger(__name__) def _A (__a , __a , __a , __a=False ) -> Union[str, Any]: """simple docstring""" try: import torch # noqa: F401 except ImportError: logger.error( '''Loading a PyTorch model in Flax, requires both PyTorch and Flax to be installed. Please see''' ''' https://pytorch.org/ and https://flax.readthedocs.io/en/latest/installation.html for installation''' ''' instructions.''' ) raise if not is_sharded: SCREAMING_SNAKE_CASE_ : Any = os.path.abspath(UpperCAmelCase_ ) logger.info(f'Loading PyTorch weights from {pt_path}' ) SCREAMING_SNAKE_CASE_ : int = torch.load(UpperCAmelCase_ , map_location='''cpu''' ) logger.info(f'PyTorch checkpoint contains {sum(t.numel() for t in pt_state_dict.values() ):,} parameters.' ) SCREAMING_SNAKE_CASE_ : Any = convert_pytorch_state_dict_to_flax(UpperCAmelCase_ , UpperCAmelCase_ ) else: # model is sharded and pytorch_checkpoint_path already contains the list of .pt shard files SCREAMING_SNAKE_CASE_ : str = convert_pytorch_sharded_state_dict_to_flax(UpperCAmelCase_ , UpperCAmelCase_ ) return flax_state_dict def _A (__a , __a , __a , __a , ) -> Union[str, Any]: """simple docstring""" def is_key_or_prefix_key_in_dict(__a ) -> bool: return len(set(UpperCAmelCase_ ) & {key, (model_prefix,) + key} ) > 0 # layer norm SCREAMING_SNAKE_CASE_ : Dict = pt_tuple_key[:-1] + ('''scale''',) if pt_tuple_key[-1] in ["weight", "gamma"] and is_key_or_prefix_key_in_dict(UpperCAmelCase_ ): return renamed_pt_tuple_key, pt_tensor # batch norm layer mean SCREAMING_SNAKE_CASE_ : Tuple = pt_tuple_key[:-1] + ('''mean''',) if pt_tuple_key[-1] == "running_mean" and not is_key_or_prefix_key_in_dict(UpperCAmelCase_ ): return renamed_pt_tuple_key, pt_tensor # batch norm layer var SCREAMING_SNAKE_CASE_ : Union[str, Any] = pt_tuple_key[:-1] + ('''var''',) if pt_tuple_key[-1] == "running_var" and not is_key_or_prefix_key_in_dict(UpperCAmelCase_ ): return renamed_pt_tuple_key, pt_tensor # embedding SCREAMING_SNAKE_CASE_ : List[Any] = pt_tuple_key[:-1] + ('''embedding''',) if pt_tuple_key[-1] == "weight" and is_key_or_prefix_key_in_dict(UpperCAmelCase_ ): return renamed_pt_tuple_key, pt_tensor # conv layer SCREAMING_SNAKE_CASE_ : int = pt_tuple_key[:-1] + ('''kernel''',) if pt_tuple_key[-1] == "weight" and pt_tensor.ndim == 4 and not is_key_or_prefix_key_in_dict(UpperCAmelCase_ ): SCREAMING_SNAKE_CASE_ : List[str] = pt_tensor.transpose(2 , 3 , 1 , 0 ) return renamed_pt_tuple_key, pt_tensor # linear layer SCREAMING_SNAKE_CASE_ : List[str] = pt_tuple_key[:-1] + ('''kernel''',) if pt_tuple_key[-1] == "weight" and not is_key_or_prefix_key_in_dict(UpperCAmelCase_ ): SCREAMING_SNAKE_CASE_ : Optional[Any] = pt_tensor.T return renamed_pt_tuple_key, pt_tensor # old PyTorch layer norm weight SCREAMING_SNAKE_CASE_ : List[Any] = pt_tuple_key[:-1] + ('''weight''',) if pt_tuple_key[-1] == "gamma": return renamed_pt_tuple_key, pt_tensor # old PyTorch layer norm bias SCREAMING_SNAKE_CASE_ : Optional[Any] = pt_tuple_key[:-1] + ('''bias''',) if pt_tuple_key[-1] == "beta": return renamed_pt_tuple_key, pt_tensor # New `weight_norm` from https://github.com/huggingface/transformers/pull/24030 SCREAMING_SNAKE_CASE_ : int = None if pt_tuple_key[-3::2] == ("parametrizations", "original0"): SCREAMING_SNAKE_CASE_ : Optional[int] = pt_tuple_key[-2] + '''_g''' elif pt_tuple_key[-3::2] == ("parametrizations", "original1"): SCREAMING_SNAKE_CASE_ : List[str] = pt_tuple_key[-2] + '''_v''' if name is not None: SCREAMING_SNAKE_CASE_ : Dict = pt_tuple_key[:-3] + (name,) return renamed_pt_tuple_key, pt_tensor return pt_tuple_key, pt_tensor def _A (__a , __a ) -> str: """simple docstring""" SCREAMING_SNAKE_CASE_ : str = {k: v.numpy() for k, v in pt_state_dict.items()} SCREAMING_SNAKE_CASE_ : str = flax_model.base_model_prefix # use params dict if the model contains batch norm layers if "params" in flax_model.params: SCREAMING_SNAKE_CASE_ : Tuple = flax_model.params['''params'''] else: SCREAMING_SNAKE_CASE_ : Dict = flax_model.params SCREAMING_SNAKE_CASE_ : int = flatten_dict(UpperCAmelCase_ ) # add batch_stats keys,values to dict if "batch_stats" in flax_model.params: SCREAMING_SNAKE_CASE_ : Dict = flatten_dict(flax_model.params['''batch_stats'''] ) random_flax_state_dict.update(UpperCAmelCase_ ) SCREAMING_SNAKE_CASE_ : int = {} SCREAMING_SNAKE_CASE_ : List[str] = (model_prefix not in flax_model_params) and ( model_prefix in {k.split('''.''' )[0] for k in pt_state_dict.keys()} ) SCREAMING_SNAKE_CASE_ : Optional[int] = (model_prefix in flax_model_params) and ( model_prefix not in {k.split('''.''' )[0] for k in pt_state_dict.keys()} ) # Need to change some parameters name to match Flax names for pt_key, pt_tensor in pt_state_dict.items(): SCREAMING_SNAKE_CASE_ : Tuple = tuple(pt_key.split('''.''' ) ) # remove base model prefix if necessary SCREAMING_SNAKE_CASE_ : Dict = pt_tuple_key[0] == model_prefix if load_model_with_head_into_base_model and has_base_model_prefix: SCREAMING_SNAKE_CASE_ : Dict = pt_tuple_key[1:] # Correctly rename weight parameters SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : int = rename_key_and_reshape_tensor( UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ ) # add model prefix if necessary SCREAMING_SNAKE_CASE_ : int = (model_prefix,) + flax_key in random_flax_state_dict if load_base_model_into_model_with_head and require_base_model_prefix: SCREAMING_SNAKE_CASE_ : Optional[int] = (model_prefix,) + flax_key if flax_key in random_flax_state_dict: if flax_tensor.shape != random_flax_state_dict[flax_key].shape: raise ValueError( f'PyTorch checkpoint seems to be incorrect. Weight {pt_key} was expected to be of shape ' f'{random_flax_state_dict[flax_key].shape}, but is {flax_tensor.shape}.' ) # add batch stats if the model contains batchnorm layers if "batch_stats" in flax_model.params: if "mean" in flax_key[-1] or "var" in flax_key[-1]: SCREAMING_SNAKE_CASE_ : Dict = jnp.asarray(UpperCAmelCase_ ) continue # remove num_batches_tracked key if "num_batches_tracked" in flax_key[-1]: flax_state_dict.pop(UpperCAmelCase_ , UpperCAmelCase_ ) continue # also add unexpected weight so that warning is thrown SCREAMING_SNAKE_CASE_ : int = jnp.asarray(UpperCAmelCase_ ) else: # also add unexpected weight so that warning is thrown SCREAMING_SNAKE_CASE_ : int = jnp.asarray(UpperCAmelCase_ ) return unflatten_dict(UpperCAmelCase_ ) def _A (__a , __a ) -> Optional[Any]: """simple docstring""" import torch # Load the index SCREAMING_SNAKE_CASE_ : Optional[Any] = {} for shard_file in shard_filenames: # load using msgpack utils SCREAMING_SNAKE_CASE_ : Tuple = torch.load(UpperCAmelCase_ ) SCREAMING_SNAKE_CASE_ : Optional[Any] = {k: v.numpy() for k, v in pt_state_dict.items()} SCREAMING_SNAKE_CASE_ : Optional[int] = flax_model.base_model_prefix # use params dict if the model contains batch norm layers and then add batch_stats keys,values to dict if "batch_stats" in flax_model.params: SCREAMING_SNAKE_CASE_ : List[str] = flax_model.params['''params'''] SCREAMING_SNAKE_CASE_ : Any = flatten_dict(UpperCAmelCase_ ) random_flax_state_dict.update(flatten_dict(flax_model.params['''batch_stats'''] ) ) else: SCREAMING_SNAKE_CASE_ : str = flax_model.params SCREAMING_SNAKE_CASE_ : int = flatten_dict(UpperCAmelCase_ ) SCREAMING_SNAKE_CASE_ : Dict = (model_prefix not in flax_model_params) and ( model_prefix in {k.split('''.''' )[0] for k in pt_state_dict.keys()} ) SCREAMING_SNAKE_CASE_ : Optional[int] = (model_prefix in flax_model_params) and ( model_prefix not in {k.split('''.''' )[0] for k in pt_state_dict.keys()} ) # Need to change some parameters name to match Flax names for pt_key, pt_tensor in pt_state_dict.items(): SCREAMING_SNAKE_CASE_ : Tuple = tuple(pt_key.split('''.''' ) ) # remove base model prefix if necessary SCREAMING_SNAKE_CASE_ : Tuple = pt_tuple_key[0] == model_prefix if load_model_with_head_into_base_model and has_base_model_prefix: SCREAMING_SNAKE_CASE_ : List[str] = pt_tuple_key[1:] # Correctly rename weight parameters SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : int = rename_key_and_reshape_tensor( UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ ) # add model prefix if necessary SCREAMING_SNAKE_CASE_ : Any = (model_prefix,) + flax_key in random_flax_state_dict if load_base_model_into_model_with_head and require_base_model_prefix: SCREAMING_SNAKE_CASE_ : Optional[int] = (model_prefix,) + flax_key if flax_key in random_flax_state_dict: if flax_tensor.shape != random_flax_state_dict[flax_key].shape: raise ValueError( f'PyTorch checkpoint seems to be incorrect. Weight {pt_key} was expected to be of shape ' f'{random_flax_state_dict[flax_key].shape}, but is {flax_tensor.shape}.' ) # add batch stats if the model contains batchnorm layers if "batch_stats" in flax_model.params: if "mean" in flax_key[-1]: SCREAMING_SNAKE_CASE_ : Dict = jnp.asarray(UpperCAmelCase_ ) continue if "var" in flax_key[-1]: SCREAMING_SNAKE_CASE_ : Union[str, Any] = jnp.asarray(UpperCAmelCase_ ) continue # remove num_batches_tracked key if "num_batches_tracked" in flax_key[-1]: flax_state_dict.pop(UpperCAmelCase_ , UpperCAmelCase_ ) continue # also add unexpected weight so that warning is thrown SCREAMING_SNAKE_CASE_ : Union[str, Any] = jnp.asarray(UpperCAmelCase_ ) else: # also add unexpected weight so that warning is thrown SCREAMING_SNAKE_CASE_ : int = jnp.asarray(UpperCAmelCase_ ) return unflatten_dict(UpperCAmelCase_ ) def _A (__a , __a ) -> int: """simple docstring""" SCREAMING_SNAKE_CASE_ : Any = os.path.abspath(UpperCAmelCase_ ) logger.info(f'Loading Flax weights from {flax_checkpoint_path}' ) # import correct flax class SCREAMING_SNAKE_CASE_ : int = getattr(UpperCAmelCase_ , '''Flax''' + model.__class__.__name__ ) # load flax weight dict with open(UpperCAmelCase_ , '''rb''' ) as state_f: try: SCREAMING_SNAKE_CASE_ : Tuple = from_bytes(UpperCAmelCase_ , state_f.read() ) except UnpicklingError: raise EnvironmentError(f'Unable to convert {flax_checkpoint_path} to Flax deserializable object. ' ) return load_flax_weights_in_pytorch_model(UpperCAmelCase_ , UpperCAmelCase_ ) def _A (__a , __a ) -> Dict: """simple docstring""" try: import torch # noqa: F401 except ImportError: logger.error( '''Loading a Flax weights in PyTorch, requires both PyTorch and Flax to be installed. Please see''' ''' https://pytorch.org/ and https://flax.readthedocs.io/en/latest/installation.html for installation''' ''' instructions.''' ) raise # check if we have bf16 weights SCREAMING_SNAKE_CASE_ : Optional[int] = flatten_dict(jax.tree_util.tree_map(lambda __a : x.dtype == jnp.bfloataa , UpperCAmelCase_ ) ).values() if any(UpperCAmelCase_ ): # convert all weights to fp32 if the are bf16 since torch.from_numpy can-not handle bf16 # and bf16 is not fully supported in PT yet. logger.warning( '''Found ``bfloat16`` weights in Flax model. Casting all ``bfloat16`` weights to ``float32`` ''' '''before loading those in PyTorch model.''' ) SCREAMING_SNAKE_CASE_ : str = jax.tree_util.tree_map( lambda __a : params.astype(np.floataa ) if params.dtype == jnp.bfloataa else params , UpperCAmelCase_ ) SCREAMING_SNAKE_CASE_ : List[str] = flatten_dict(UpperCAmelCase_ ) SCREAMING_SNAKE_CASE_ : Optional[Any] = pt_model.state_dict() SCREAMING_SNAKE_CASE_ : Union[str, Any] = (pt_model.base_model_prefix in flax_state) and ( pt_model.base_model_prefix not in {k.split('''.''' )[0] for k in pt_model_dict.keys()} ) SCREAMING_SNAKE_CASE_ : Tuple = (pt_model.base_model_prefix not in flax_state) and ( pt_model.base_model_prefix in {k.split('''.''' )[0] for k in pt_model_dict.keys()} ) # keep track of unexpected & missing keys SCREAMING_SNAKE_CASE_ : Tuple = [] SCREAMING_SNAKE_CASE_ : Union[str, Any] = set(pt_model_dict.keys() ) for flax_key_tuple, flax_tensor in flax_state_dict.items(): SCREAMING_SNAKE_CASE_ : Tuple = flax_key_tuple[0] == pt_model.base_model_prefix SCREAMING_SNAKE_CASE_ : Optional[int] = '''.'''.join((pt_model.base_model_prefix,) + flax_key_tuple ) in pt_model_dict # adapt flax_key to prepare for loading from/to base model only if load_model_with_head_into_base_model and has_base_model_prefix: SCREAMING_SNAKE_CASE_ : Dict = flax_key_tuple[1:] elif load_base_model_into_model_with_head and require_base_model_prefix: SCREAMING_SNAKE_CASE_ : Any = (pt_model.base_model_prefix,) + flax_key_tuple # rename flax weights to PyTorch format if flax_key_tuple[-1] == "kernel" and flax_tensor.ndim == 4 and ".".join(UpperCAmelCase_ ) not in pt_model_dict: # conv layer SCREAMING_SNAKE_CASE_ : Optional[Any] = flax_key_tuple[:-1] + ('''weight''',) SCREAMING_SNAKE_CASE_ : List[str] = jnp.transpose(UpperCAmelCase_ , (3, 2, 0, 1) ) elif flax_key_tuple[-1] == "kernel" and ".".join(UpperCAmelCase_ ) not in pt_model_dict: # linear layer SCREAMING_SNAKE_CASE_ : Optional[int] = flax_key_tuple[:-1] + ('''weight''',) SCREAMING_SNAKE_CASE_ : str = flax_tensor.T elif flax_key_tuple[-1] in ["scale", "embedding"]: SCREAMING_SNAKE_CASE_ : Tuple = flax_key_tuple[:-1] + ('''weight''',) # adding batch stats from flax batch norm to pt elif "mean" in flax_key_tuple[-1]: SCREAMING_SNAKE_CASE_ : int = flax_key_tuple[:-1] + ('''running_mean''',) elif "var" in flax_key_tuple[-1]: SCREAMING_SNAKE_CASE_ : Optional[Any] = flax_key_tuple[:-1] + ('''running_var''',) if "batch_stats" in flax_state: SCREAMING_SNAKE_CASE_ : Union[str, Any] = '''.'''.join(flax_key_tuple[1:] ) # Remove the params/batch_stats header else: SCREAMING_SNAKE_CASE_ : Union[str, Any] = '''.'''.join(UpperCAmelCase_ ) # We also need to look at `pt_model_dict` and see if there are keys requiring further transformation. SCREAMING_SNAKE_CASE_ : Optional[int] = {} # New `weight_norm` from https://github.com/huggingface/transformers/pull/24030 for key in pt_model_dict: SCREAMING_SNAKE_CASE_ : int = key.split('''.''' ) SCREAMING_SNAKE_CASE_ : int = None if key_components[-3::2] == ["parametrizations", "original0"]: SCREAMING_SNAKE_CASE_ : int = key_components[-2] + '''_g''' elif key_components[-3::2] == ["parametrizations", "original1"]: SCREAMING_SNAKE_CASE_ : List[Any] = key_components[-2] + '''_v''' if name is not None: SCREAMING_SNAKE_CASE_ : Any = key_components[:-3] + [name] SCREAMING_SNAKE_CASE_ : int = '''.'''.join(UpperCAmelCase_ ) SCREAMING_SNAKE_CASE_ : int = key if flax_key in special_pt_names: SCREAMING_SNAKE_CASE_ : Tuple = special_pt_names[flax_key] if flax_key in pt_model_dict: if flax_tensor.shape != pt_model_dict[flax_key].shape: raise ValueError( f'Flax checkpoint seems to be incorrect. Weight {flax_key_tuple} was expected ' f'to be of shape {pt_model_dict[flax_key].shape}, but is {flax_tensor.shape}.' ) else: # add weight to pytorch dict SCREAMING_SNAKE_CASE_ : Union[str, Any] = np.asarray(UpperCAmelCase_ ) if not isinstance(UpperCAmelCase_ , np.ndarray ) else flax_tensor SCREAMING_SNAKE_CASE_ : Optional[Any] = torch.from_numpy(UpperCAmelCase_ ) # remove from missing keys missing_keys.remove(UpperCAmelCase_ ) else: # weight is not expected by PyTorch model unexpected_keys.append(UpperCAmelCase_ ) pt_model.load_state_dict(UpperCAmelCase_ ) # re-transform missing_keys to list SCREAMING_SNAKE_CASE_ : Optional[Any] = list(UpperCAmelCase_ ) if len(UpperCAmelCase_ ) > 0: logger.warning( '''Some weights of the Flax model were not used when initializing the PyTorch model''' f' {pt_model.__class__.__name__}: {unexpected_keys}\n- This IS expected if you are initializing' f' {pt_model.__class__.__name__} from a Flax model trained on another task or with another architecture' ''' (e.g. initializing a BertForSequenceClassification model from a FlaxBertForPreTraining model).\n- This''' f' IS NOT expected if you are initializing {pt_model.__class__.__name__} from a Flax model that you expect' ''' to be exactly identical (e.g. initializing a BertForSequenceClassification model from a''' ''' FlaxBertForSequenceClassification model).''' ) else: logger.warning(f'All Flax model weights were used when initializing {pt_model.__class__.__name__}.\n' ) if len(UpperCAmelCase_ ) > 0: logger.warning( f'Some weights of {pt_model.__class__.__name__} were not initialized from the Flax model and are newly' f' initialized: {missing_keys}\nYou should probably TRAIN this model on a down-stream task to be able to' ''' use it for predictions and inference.''' ) else: logger.warning( f'All the weights of {pt_model.__class__.__name__} were initialized from the Flax model.\n' '''If your task is similar to the task the model of the checkpoint was trained on, ''' f'you can already use {pt_model.__class__.__name__} for predictions without further training.' ) return pt_model
353
"""simple docstring""" from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCAmelCase_ : Dict = logging.get_logger(__name__) UpperCAmelCase_ : List[str] = { """RWKV/rwkv-4-169m-pile""": """https://huggingface.co/RWKV/rwkv-4-169m-pile/resolve/main/config.json""", """RWKV/rwkv-4-430m-pile""": """https://huggingface.co/RWKV/rwkv-4-430m-pile/resolve/main/config.json""", """RWKV/rwkv-4-1b5-pile""": """https://huggingface.co/RWKV/rwkv-4-1b5-pile/resolve/main/config.json""", """RWKV/rwkv-4-3b-pile""": """https://huggingface.co/RWKV/rwkv-4-3b-pile/resolve/main/config.json""", """RWKV/rwkv-4-7b-pile""": """https://huggingface.co/RWKV/rwkv-4-7b-pile/resolve/main/config.json""", """RWKV/rwkv-4-14b-pile""": """https://huggingface.co/RWKV/rwkv-4-14b-pile/resolve/main/config.json""", """RWKV/rwkv-raven-1b5""": """https://huggingface.co/RWKV/rwkv-raven-1b5/resolve/main/config.json""", """RWKV/rwkv-raven-3b""": """https://huggingface.co/RWKV/rwkv-raven-3b/resolve/main/config.json""", """RWKV/rwkv-raven-7b""": """https://huggingface.co/RWKV/rwkv-raven-7b/resolve/main/config.json""", """RWKV/rwkv-raven-14b""": """https://huggingface.co/RWKV/rwkv-raven-14b/resolve/main/config.json""", } class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = "rwkv" __UpperCamelCase = {"max_position_embeddings": "context_length"} def __init__( self : Union[str, Any] , lowercase_ : Any=50277 , lowercase_ : str=1024 , lowercase_ : List[str]=4096 , lowercase_ : Optional[Any]=32 , lowercase_ : Any=None , lowercase_ : Any=None , lowercase_ : List[Any]=1e-5 , lowercase_ : Union[str, Any]=0 , lowercase_ : Union[str, Any]=0 , lowercase_ : int=6 , lowercase_ : Tuple=False , lowercase_ : Any=True , **lowercase_ : Any , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = vocab_size SCREAMING_SNAKE_CASE_ : Any = context_length SCREAMING_SNAKE_CASE_ : int = hidden_size SCREAMING_SNAKE_CASE_ : int = num_hidden_layers SCREAMING_SNAKE_CASE_ : List[str] = attention_hidden_size if attention_hidden_size is not None else hidden_size SCREAMING_SNAKE_CASE_ : int = intermediate_size if intermediate_size is not None else 4 * hidden_size SCREAMING_SNAKE_CASE_ : int = layer_norm_epsilon SCREAMING_SNAKE_CASE_ : Optional[int] = rescale_every SCREAMING_SNAKE_CASE_ : Dict = use_cache SCREAMING_SNAKE_CASE_ : Dict = bos_token_id SCREAMING_SNAKE_CASE_ : Any = eos_token_id super().__init__( tie_word_embeddings=lowercase_ , bos_token_id=lowercase_ , eos_token_id=lowercase_ , **lowercase_)
318
0
"""simple docstring""" import copy import os from typing import Union from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCAmelCase_ = logging.get_logger(__name__) UpperCAmelCase_ = { '''microsoft/git-base''': '''https://huggingface.co/microsoft/git-base/resolve/main/config.json''', } class lowerCAmelCase__ ( lowerCamelCase__ ): '''simple docstring''' __UpperCamelCase = "git_vision_model" def __init__( self : Union[str, Any] , lowercase_ : str=768 , lowercase_ : str=3072 , lowercase_ : Optional[Any]=12 , lowercase_ : Any=12 , lowercase_ : Dict=3 , lowercase_ : Union[str, Any]=224 , lowercase_ : Optional[int]=16 , lowercase_ : Union[str, Any]="quick_gelu" , lowercase_ : Optional[int]=1e-5 , lowercase_ : List[str]=0.0 , lowercase_ : Any=0.02 , **lowercase_ : str , ): '''simple docstring''' super().__init__(**lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = hidden_size SCREAMING_SNAKE_CASE_ : Optional[Any] = intermediate_size SCREAMING_SNAKE_CASE_ : Dict = num_hidden_layers SCREAMING_SNAKE_CASE_ : int = num_attention_heads SCREAMING_SNAKE_CASE_ : int = num_channels SCREAMING_SNAKE_CASE_ : Tuple = patch_size SCREAMING_SNAKE_CASE_ : Dict = image_size SCREAMING_SNAKE_CASE_ : Optional[int] = initializer_range SCREAMING_SNAKE_CASE_ : str = attention_dropout SCREAMING_SNAKE_CASE_ : Tuple = layer_norm_eps SCREAMING_SNAKE_CASE_ : List[str] = hidden_act @classmethod def _SCREAMING_SNAKE_CASE ( cls : Any , lowercase_ : Union[str, os.PathLike] , **lowercase_ : List[str]): '''simple docstring''' cls._set_token_in_kwargs(lowercase_) SCREAMING_SNAKE_CASE_ : Optional[Any] = cls.get_config_dict(lowercase_ , **lowercase_) # get the vision config dict if we are loading from GITConfig if config_dict.get('''model_type''') == "git": SCREAMING_SNAKE_CASE_ : int = 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 lowerCAmelCase__ ( lowerCamelCase__ ): '''simple docstring''' __UpperCamelCase = "git" def __init__( self : List[str] , lowercase_ : Any=None , lowercase_ : int=30522 , lowercase_ : Dict=768 , lowercase_ : List[Any]=6 , lowercase_ : Any=12 , lowercase_ : Any=3072 , lowercase_ : List[Any]="gelu" , lowercase_ : Union[str, Any]=0.1 , lowercase_ : Any=0.1 , lowercase_ : Optional[int]=1024 , lowercase_ : str=0.02 , lowercase_ : int=1e-12 , lowercase_ : Optional[int]=0 , lowercase_ : int="absolute" , lowercase_ : Tuple=True , lowercase_ : List[str]=False , lowercase_ : List[str]=101 , lowercase_ : int=102 , lowercase_ : str=None , **lowercase_ : List[Any] , ): '''simple docstring''' super().__init__(bos_token_id=lowercase_ , eos_token_id=lowercase_ , pad_token_id=lowercase_ , **lowercase_) if vision_config is None: SCREAMING_SNAKE_CASE_ : Union[str, Any] = {} logger.info('''vision_config is None. initializing the GitVisionConfig with default values.''') SCREAMING_SNAKE_CASE_ : List[Any] = GitVisionConfig(**lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = vocab_size SCREAMING_SNAKE_CASE_ : List[str] = hidden_size SCREAMING_SNAKE_CASE_ : int = num_hidden_layers SCREAMING_SNAKE_CASE_ : Union[str, Any] = num_attention_heads SCREAMING_SNAKE_CASE_ : List[str] = hidden_act SCREAMING_SNAKE_CASE_ : Dict = intermediate_size SCREAMING_SNAKE_CASE_ : Tuple = hidden_dropout_prob SCREAMING_SNAKE_CASE_ : str = attention_probs_dropout_prob SCREAMING_SNAKE_CASE_ : Any = max_position_embeddings SCREAMING_SNAKE_CASE_ : List[str] = initializer_range SCREAMING_SNAKE_CASE_ : int = layer_norm_eps SCREAMING_SNAKE_CASE_ : Dict = position_embedding_type SCREAMING_SNAKE_CASE_ : str = use_cache SCREAMING_SNAKE_CASE_ : str = tie_word_embeddings SCREAMING_SNAKE_CASE_ : Optional[Any] = num_image_with_embedding SCREAMING_SNAKE_CASE_ : int = bos_token_id SCREAMING_SNAKE_CASE_ : Optional[int] = eos_token_id def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = copy.deepcopy(self.__dict__) SCREAMING_SNAKE_CASE_ : Optional[int] = self.vision_config.to_dict() SCREAMING_SNAKE_CASE_ : Optional[Any] = self.__class__.model_type return output
354
"""simple docstring""" UpperCAmelCase_ : Optional[int] = 8.3_1_4_4_5_9_8 def _A (__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 UpperCAmelCase_ : str = 300 UpperCAmelCase_ : str = 28 UpperCAmelCase_ : Any = rms_speed_of_molecule(temperature, molar_mass) print(f'''Vrms of Nitrogen gas at 300 K is {vrms} m/s''')
318
0
"""simple docstring""" from manim import * class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = Rectangle(height=0.5 , width=0.5) SCREAMING_SNAKE_CASE_ : str = Rectangle(height=0.46 , width=0.46).set_stroke(width=0) SCREAMING_SNAKE_CASE_ : Optional[int] = [mem.copy() for i in range(6)] SCREAMING_SNAKE_CASE_ : Tuple = [mem.copy() for i in range(6)] SCREAMING_SNAKE_CASE_ : Optional[int] = VGroup(*lowerCamelCase_).arrange(lowerCamelCase_ , buff=0) SCREAMING_SNAKE_CASE_ : Any = VGroup(*lowerCamelCase_).arrange(lowerCamelCase_ , buff=0) SCREAMING_SNAKE_CASE_ : List[Any] = VGroup(lowerCamelCase_ , lowerCamelCase_).arrange(lowerCamelCase_ , buff=0) SCREAMING_SNAKE_CASE_ : Optional[Any] = Text('''CPU''' , font_size=24) SCREAMING_SNAKE_CASE_ : Dict = Group(lowerCamelCase_ , lowerCamelCase_).arrange(lowerCamelCase_ , buff=0.5 , aligned_edge=lowerCamelCase_) cpu.move_to([-2.5, -0.5, 0]) self.add(lowerCamelCase_) SCREAMING_SNAKE_CASE_ : Optional[Any] = [mem.copy() for i in range(1)] SCREAMING_SNAKE_CASE_ : Tuple = VGroup(*lowerCamelCase_).arrange(lowerCamelCase_ , buff=0) SCREAMING_SNAKE_CASE_ : Optional[Any] = Text('''GPU''' , font_size=24) SCREAMING_SNAKE_CASE_ : str = Group(lowerCamelCase_ , lowerCamelCase_).arrange(lowerCamelCase_ , buff=0.5 , aligned_edge=lowerCamelCase_) gpu.align_to(lowerCamelCase_ , lowerCamelCase_) gpu.set_x(gpu.get_x() - 1) self.add(lowerCamelCase_) SCREAMING_SNAKE_CASE_ : Optional[int] = [mem.copy() for i in range(6)] SCREAMING_SNAKE_CASE_ : List[Any] = VGroup(*lowerCamelCase_).arrange(lowerCamelCase_ , buff=0) SCREAMING_SNAKE_CASE_ : Union[str, Any] = Text('''Model''' , font_size=24) SCREAMING_SNAKE_CASE_ : Optional[Any] = Group(lowerCamelCase_ , lowerCamelCase_).arrange(lowerCamelCase_ , buff=0.5 , aligned_edge=lowerCamelCase_) model.move_to([3, -1.0, 0]) self.play( Create(lowerCamelCase_ , run_time=1) , Create(lowerCamelCase_ , run_time=1) , Create(lowerCamelCase_ , run_time=1) , ) SCREAMING_SNAKE_CASE_ : List[Any] = MarkupText( F'First, an empty model skeleton is loaded\ninto <span fgcolor=\'{YELLOW}\'>memory</span> without using much RAM.' , font_size=24 , ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = Square(side_length=2.2) key.move_to([-5, 2, 0]) SCREAMING_SNAKE_CASE_ : List[str] = MarkupText( F'<b>Key:</b>\n\n<span fgcolor=\'{YELLOW}\'>●</span> Empty Model' , font_size=18 , ) key_text.move_to([-5, 2.4, 0]) step_a.move_to([2, 2, 0]) self.play(Write(lowerCamelCase_ , run_time=2.5) , Write(lowerCamelCase_) , Write(lowerCamelCase_)) self.add(lowerCamelCase_) SCREAMING_SNAKE_CASE_ : str = [] SCREAMING_SNAKE_CASE_ : Any = [] SCREAMING_SNAKE_CASE_ : Tuple = [] for i, rect in enumerate(lowerCamelCase_): SCREAMING_SNAKE_CASE_ : Optional[Any] = Rectangle(height=0.46 , width=0.46).set_stroke(width=0.0).set_fill(lowerCamelCase_ , opacity=0.7) cpu_target.move_to(lowerCamelCase_) cpu_target.generate_target() SCREAMING_SNAKE_CASE_ : int = 0.46 / 4 SCREAMING_SNAKE_CASE_ : Dict = 0.46 / 3 if i == 0: cpu_target.target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT) , buff=0.02 , direction=lowerCamelCase_) cpu_target.target.set_x(cpu_target.target.get_x() + 0.1) elif i == 3: cpu_target.target.next_to(cpu_targs[0].target , direction=lowerCamelCase_ , buff=0.0) else: cpu_target.target.next_to(cpu_targs[i - 1].target , direction=lowerCamelCase_ , buff=0.0) cpu_targs.append(lowerCamelCase_) first_animations.append(rect.animate(run_time=0.5).set_stroke(lowerCamelCase_)) second_animations.append(MoveToTarget(lowerCamelCase_ , run_time=1.5)) self.play(*lowerCamelCase_) self.play(*lowerCamelCase_) self.wait()
355
"""simple docstring""" import json import multiprocessing import os import re from collections import defaultdict import torch from accelerate import Accelerator from accelerate.utils import set_seed from arguments import HumanEvalArguments from datasets import load_dataset, load_metric from torch.utils.data import IterableDataset from torch.utils.data.dataloader import DataLoader from tqdm import tqdm import transformers from transformers import AutoModelForCausalLM, AutoTokenizer, HfArgumentParser, StoppingCriteria, StoppingCriteriaList UpperCAmelCase_ : Union[str, Any] = ["""\nclass""", """\ndef""", """\n#""", """\n@""", """\nprint""", """\nif"""] class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def __init__( self : List[Any] , lowercase_ : Tuple , lowercase_ : Optional[int] , lowercase_ : int=None , lowercase_ : Dict=1): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = tokenizer SCREAMING_SNAKE_CASE_ : Optional[int] = dataset SCREAMING_SNAKE_CASE_ : Optional[Any] = len(lowercase_) if n_tasks is None else n_tasks SCREAMING_SNAKE_CASE_ : Optional[int] = n_copies def __iter__( self : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = [] for task in range(self.n_tasks): # without strip, the model generate commented codes ... prompts.append(self.tokenizer.eos_token + self.dataset[task]['''prompt'''].strip()) SCREAMING_SNAKE_CASE_ : Optional[Any] = self.tokenizer(lowercase_ , padding=lowercase_ , return_tensors='''pt''') for task in range(self.n_tasks): for _ in range(self.n_copies): yield { "ids": outputs.input_ids[task], "task_id": task, "input_len": outputs.attention_mask[task].sum(), } class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def __init__( self : int , lowercase_ : Dict , lowercase_ : Optional[Any] , lowercase_ : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = start_length SCREAMING_SNAKE_CASE_ : List[Any] = eof_strings SCREAMING_SNAKE_CASE_ : List[Any] = tokenizer def __call__( self : Optional[int] , lowercase_ : Any , lowercase_ : int , **lowercase_ : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = self.tokenizer.batch_decode(input_ids[:, self.start_length :]) SCREAMING_SNAKE_CASE_ : Tuple = [] for decoded_generation in decoded_generations: done.append(any(stop_string in decoded_generation for stop_string in self.eof_strings)) return all(lowercase_) def _A (__a ) -> Union[str, Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Dict = re.split('''(%s)''' % '''|'''.join(__a ) , __a ) # last string should be "" return "".join(string_list[:-2] ) def _A (__a , __a , __a , __a , __a , __a=20 , **__a ) -> List[str]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Tuple = defaultdict(__a ) # dict of list of generated tokens for step, batch in tqdm(enumerate(__a ) ): with torch.no_grad(): SCREAMING_SNAKE_CASE_ : Optional[int] = batch['''ids'''].shape[-1] SCREAMING_SNAKE_CASE_ : Tuple = accelerator.unwrap_model(__a ).generate( input_ids=batch['''ids'''][:, : batch['''input_len''']] , num_return_sequences=__a , **__a ) # each task is generated batch_size times SCREAMING_SNAKE_CASE_ : List[Any] = batch['''task_id'''].repeat(__a ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = accelerator.pad_across_processes( __a , dim=1 , pad_index=tokenizer.pad_token_id ) SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Union[str, Any] = accelerator.gather((generated_tokens, generated_tasks) ) SCREAMING_SNAKE_CASE_ : int = generated_tokens.cpu().numpy() SCREAMING_SNAKE_CASE_ : Optional[Any] = generated_tasks.cpu().numpy() for task, generated_tokens in zip(__a , __a ): gen_token_dict[task].append(__a ) SCREAMING_SNAKE_CASE_ : int = [[] for _ in range(__a )] for task, generated_tokens in gen_token_dict.items(): for s in generated_tokens: SCREAMING_SNAKE_CASE_ : Optional[int] = tokenizer.decode(__a , skip_special_tokens=__a , clean_up_tokenization_spaces=__a ) code_gens[task].append(remove_last_block(__a ) ) return code_gens def _A () -> Optional[int]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Union[str, Any] = HfArgumentParser(__a ) SCREAMING_SNAKE_CASE_ : List[Any] = parser.parse_args() transformers.logging.set_verbosity_error() # enables code execution in code_eval metric SCREAMING_SNAKE_CASE_ : Any = args.HF_ALLOW_CODE_EVAL # make sure tokenizer plays nice with multiprocessing SCREAMING_SNAKE_CASE_ : str = '''false''' if args.num_workers is None: SCREAMING_SNAKE_CASE_ : Optional[Any] = multiprocessing.cpu_count() # Use dataset load to feed to accelerate SCREAMING_SNAKE_CASE_ : Tuple = Accelerator() set_seed(args.seed , device_specific=__a ) # Load model and tokenizer SCREAMING_SNAKE_CASE_ : Dict = AutoTokenizer.from_pretrained(args.model_ckpt ) SCREAMING_SNAKE_CASE_ : Dict = tokenizer.eos_token SCREAMING_SNAKE_CASE_ : Optional[int] = AutoModelForCausalLM.from_pretrained(args.model_ckpt ) # Generation settings SCREAMING_SNAKE_CASE_ : List[str] = { '''do_sample''': args.do_sample, '''temperature''': args.temperature, '''max_new_tokens''': args.max_new_tokens, '''top_p''': args.top_p, '''top_k''': args.top_k, '''stopping_criteria''': StoppingCriteriaList([EndOfFunctionCriteria(0 , __a , __a )] ), } # Load evaluation dataset and metric SCREAMING_SNAKE_CASE_ : Optional[int] = load_dataset('''openai_humaneval''' ) SCREAMING_SNAKE_CASE_ : str = load_metric('''code_eval''' ) SCREAMING_SNAKE_CASE_ : int = args.num_tasks if args.num_tasks is not None else len(human_eval['''test'''] ) SCREAMING_SNAKE_CASE_ : List[str] = args.n_samples // args.batch_size SCREAMING_SNAKE_CASE_ : Union[str, Any] = TokenizedDataset(__a , human_eval['''test'''] , n_copies=__a , n_tasks=__a ) # do not confuse args.batch_size, which is actually the num_return_sequences SCREAMING_SNAKE_CASE_ : Optional[int] = DataLoader(__a , batch_size=1 ) # Run a quick test to see if code evaluation is enabled try: SCREAMING_SNAKE_CASE_ : Any = code_eval_metric.compute(references=[''''''] , predictions=[['''''']] ) except ValueError as exception: print( '''Code evaluation not enabled. Read the warning below carefully and then use `--HF_ALLOW_CODE_EVAL="1"`''' ''' flag to enable code evaluation.''' ) raise exception SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : int = accelerator.prepare(__a , __a ) SCREAMING_SNAKE_CASE_ : List[Any] = complete_code( __a , __a , __a , __a , n_tasks=__a , batch_size=args.batch_size , **__a , ) if accelerator.is_main_process: SCREAMING_SNAKE_CASE_ : int = [] for task in tqdm(range(__a ) ): SCREAMING_SNAKE_CASE_ : Tuple = human_eval['''test'''][task]['''test'''] SCREAMING_SNAKE_CASE_ : Tuple = f'check({human_eval["test"][task]["entry_point"]})' references.append('''\n''' + test_func + '''\n''' + entry_point ) # Evaluate completions with "code_eval" metric SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Dict = code_eval_metric.compute( references=__a , predictions=__a , num_workers=args.num_workers ) print(f'Results: {pass_at_k}' ) # Save results to json file with open(args.output_file , '''w''' ) as fp: json.dump(__a , __a ) # For some reason the folliwng seems to be necessary sometimes for code_eval to work nice with multiprocessing # https://stackoverflow.com/questions/60804599/python-multiprocessing-keeps-spawning-the-whole-script if __name__ == "__main__": main()
318
0
"""simple docstring""" import unittest import numpy as np def _A (__a , __a , __a , __a = None , ) -> np.ndarray: """simple docstring""" SCREAMING_SNAKE_CASE_ : Union[str, Any] = np.shape(__UpperCAmelCase ) SCREAMING_SNAKE_CASE_ : str = np.shape(__UpperCAmelCase ) SCREAMING_SNAKE_CASE_ : Optional[int] = np.shape(__UpperCAmelCase ) if shape_a[0] != shape_b[0]: SCREAMING_SNAKE_CASE_ : List[Any] = ( '''Expected the same number of rows for A and B. ''' f'Instead found A of size {shape_a} and B of size {shape_b}' ) raise ValueError(__UpperCAmelCase ) if shape_b[1] != shape_c[1]: SCREAMING_SNAKE_CASE_ : Union[str, Any] = ( '''Expected the same number of columns for B and C. ''' f'Instead found B of size {shape_b} and C of size {shape_c}' ) raise ValueError(__UpperCAmelCase ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = pseudo_inv if a_inv is None: try: SCREAMING_SNAKE_CASE_ : Dict = np.linalg.inv(__UpperCAmelCase ) except np.linalg.LinAlgError: raise ValueError( '''Input matrix A is not invertible. Cannot compute Schur complement.''' ) return mat_c - mat_b.T @ a_inv @ mat_b class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : Tuple): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = np.array([[1, 2, 1], [2, 1, 2], [3, 2, 4]]) SCREAMING_SNAKE_CASE_ : int = np.array([[0, 3], [3, 0], [2, 3]]) SCREAMING_SNAKE_CASE_ : Union[str, Any] = np.array([[2, 1], [6, 3]]) SCREAMING_SNAKE_CASE_ : int = schur_complement(lowercase_ , lowercase_ , lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = np.block([[a, b], [b.T, c]]) SCREAMING_SNAKE_CASE_ : Union[str, Any] = np.linalg.det(lowercase_) SCREAMING_SNAKE_CASE_ : Union[str, Any] = np.linalg.det(lowercase_) SCREAMING_SNAKE_CASE_ : List[Any] = np.linalg.det(lowercase_) self.assertAlmostEqual(lowercase_ , det_a * det_s) def _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = np.array([[1, 2, 1], [2, 1, 2], [3, 2, 4]]) SCREAMING_SNAKE_CASE_ : int = np.array([[0, 3], [3, 0], [2, 3]]) SCREAMING_SNAKE_CASE_ : Optional[int] = np.array([[2, 1], [6, 3]]) with self.assertRaises(lowercase_): schur_complement(lowercase_ , lowercase_ , lowercase_) def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = np.array([[1, 2, 1], [2, 1, 2], [3, 2, 4]]) SCREAMING_SNAKE_CASE_ : Any = np.array([[0, 3], [3, 0], [2, 3]]) SCREAMING_SNAKE_CASE_ : Dict = np.array([[2, 1, 3], [6, 3, 5]]) with self.assertRaises(lowercase_): schur_complement(lowercase_ , lowercase_ , lowercase_) if __name__ == "__main__": import doctest doctest.testmod() unittest.main()
356
"""simple docstring""" from ...processing_utils import ProcessorMixin class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = ["image_processor", "feature_extractor"] __UpperCamelCase = "TvltImageProcessor" __UpperCamelCase = "TvltFeatureExtractor" def __init__( self : int , lowercase_ : Optional[Any] , lowercase_ : Optional[Any]): '''simple docstring''' super().__init__(image_processor=lowercase_ , feature_extractor=lowercase_) SCREAMING_SNAKE_CASE_ : Union[str, Any] = image_processor SCREAMING_SNAKE_CASE_ : Optional[Any] = feature_extractor def __call__( self : Any , lowercase_ : str=None , lowercase_ : Optional[Any]=None , lowercase_ : Optional[Any]=None , lowercase_ : str=None , lowercase_ : int=False , lowercase_ : Union[str, Any]=False , *lowercase_ : List[Any] , **lowercase_ : List[str] , ): '''simple docstring''' if images is None and audio is None: raise ValueError('''You need to specify either an `images` or `audio` input to process.''') SCREAMING_SNAKE_CASE_ : Any = None if images is not None: SCREAMING_SNAKE_CASE_ : Tuple = self.image_processor(lowercase_ , mask_pixel=lowercase_ , *lowercase_ , **lowercase_) if images_mixed is not None: SCREAMING_SNAKE_CASE_ : Optional[int] = self.image_processor(lowercase_ , is_mixed=lowercase_ , *lowercase_ , **lowercase_) if audio is not None: SCREAMING_SNAKE_CASE_ : Any = self.feature_extractor( lowercase_ , *lowercase_ , sampling_rate=lowercase_ , mask_audio=lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : List[Any] = {} if audio is not None: output_dict.update(lowercase_) if images is not None: output_dict.update(lowercase_) if images_mixed_dict is not None: output_dict.update(lowercase_) return output_dict @property def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = self.image_processor.model_input_names SCREAMING_SNAKE_CASE_ : Dict = self.feature_extractor.model_input_names return list(dict.fromkeys(image_processor_input_names + feature_extractor_input_names))
318
0
"""simple docstring""" import unittest from transformers import DebertaVaTokenizer, DebertaVaTokenizerFast from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow from ...test_tokenization_common import TokenizerTesterMixin UpperCAmelCase_ : List[Any] = get_tests_dir("""fixtures/spiece.model""") @require_sentencepiece @require_tokenizers class lowerCAmelCase__ ( A__ , unittest.TestCase ): '''simple docstring''' __UpperCamelCase = DebertaVaTokenizer __UpperCamelCase = DebertaVaTokenizerFast __UpperCamelCase = True __UpperCamelCase = True def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' super().setUp() # We have a SentencePiece fixture for testing SCREAMING_SNAKE_CASE_ : List[Any] = DebertaVaTokenizer(lowerCamelCase__ , unk_token='''<unk>''') tokenizer.save_pretrained(self.tmpdirname) def _SCREAMING_SNAKE_CASE ( self : str , lowercase_ : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = '''this is a test''' SCREAMING_SNAKE_CASE_ : Dict = '''this is a test''' return input_text, output_text def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = '''<pad>''' SCREAMING_SNAKE_CASE_ : List[str] = 0 self.assertEqual(self.get_tokenizer()._convert_token_to_id(lowerCamelCase__) , lowerCamelCase__) self.assertEqual(self.get_tokenizer()._convert_id_to_token(lowerCamelCase__) , lowerCamelCase__) def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = list(self.get_tokenizer().get_vocab().keys()) self.assertEqual(vocab_keys[0] , '''<pad>''') self.assertEqual(vocab_keys[1] , '''<unk>''') self.assertEqual(vocab_keys[-1] , '''[PAD]''') self.assertEqual(len(lowerCamelCase__) , 30001) def _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' self.assertEqual(self.get_tokenizer().vocab_size , 30000) def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = ''' \tHeLLo!how \n Are yoU? ''' SCREAMING_SNAKE_CASE_ : List[Any] = ['''▁hello''', '''!''', '''how''', '''▁are''', '''▁you''', '''?'''] # fmt: on SCREAMING_SNAKE_CASE_ : Union[str, Any] = DebertaVaTokenizer(lowerCamelCase__ , do_lower_case=lowerCamelCase__) SCREAMING_SNAKE_CASE_ : Optional[Any] = tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCamelCase__ , add_special_tokens=lowerCamelCase__)) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) SCREAMING_SNAKE_CASE_ : Optional[Any] = DebertaVaTokenizerFast(lowerCamelCase__ , do_lower_case=lowerCamelCase__) SCREAMING_SNAKE_CASE_ : Tuple = rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCamelCase__ , add_special_tokens=lowerCamelCase__)) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) @unittest.skip('''There is an inconsistency between slow and fast tokenizer due to a bug in the fast one.''') def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' pass @unittest.skip('''There is an inconsistency between slow and fast tokenizer due to a bug in the fast one.''') def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' pass def _SCREAMING_SNAKE_CASE ( self : Any): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = '''I was born in 92000, and this is falsé.''' SCREAMING_SNAKE_CASE_ : List[Any] = ['''▁''', '''<unk>''', '''▁was''', '''▁born''', '''▁in''', '''▁9''', '''2000''', '''▁''', ''',''', '''▁and''', '''▁this''', '''▁is''', '''▁fal''', '''s''', '''<unk>''', '''▁''', '''.''', ] # fmt: on SCREAMING_SNAKE_CASE_ : int = DebertaVaTokenizer(lowerCamelCase__ , split_by_punct=lowerCamelCase__) SCREAMING_SNAKE_CASE_ : Union[str, Any] = tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCamelCase__ , add_special_tokens=lowerCamelCase__)) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) SCREAMING_SNAKE_CASE_ : str = DebertaVaTokenizerFast(lowerCamelCase__ , split_by_punct=lowerCamelCase__) SCREAMING_SNAKE_CASE_ : Dict = rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCamelCase__ , add_special_tokens=lowerCamelCase__)) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = '''I was born in 92000, and this is falsé.''' SCREAMING_SNAKE_CASE_ : Optional[int] = ['''▁i''', '''▁was''', '''▁born''', '''▁in''', '''▁9''', '''2000''', '''▁''', ''',''', '''▁and''', '''▁this''', '''▁is''', '''▁fal''', '''s''', '''<unk>''', '''▁''', '''.''', ] # fmt: on SCREAMING_SNAKE_CASE_ : str = DebertaVaTokenizer(lowerCamelCase__ , do_lower_case=lowerCamelCase__ , split_by_punct=lowerCamelCase__) SCREAMING_SNAKE_CASE_ : List[Any] = tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCamelCase__ , add_special_tokens=lowerCamelCase__)) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) SCREAMING_SNAKE_CASE_ : List[str] = DebertaVaTokenizerFast(lowerCamelCase__ , do_lower_case=lowerCamelCase__ , split_by_punct=lowerCamelCase__) SCREAMING_SNAKE_CASE_ : Any = rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCamelCase__ , add_special_tokens=lowerCamelCase__)) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = '''I was born in 92000, and this is falsé.''' SCREAMING_SNAKE_CASE_ : Dict = ['''▁i''', '''▁was''', '''▁born''', '''▁in''', '''▁9''', '''2000''', ''',''', '''▁and''', '''▁this''', '''▁is''', '''▁fal''', '''s''', '''<unk>''', '''.''', ] # fmt: on SCREAMING_SNAKE_CASE_ : Tuple = DebertaVaTokenizer(lowerCamelCase__ , do_lower_case=lowerCamelCase__ , split_by_punct=lowerCamelCase__) SCREAMING_SNAKE_CASE_ : Dict = tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCamelCase__ , add_special_tokens=lowerCamelCase__)) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) SCREAMING_SNAKE_CASE_ : Any = DebertaVaTokenizerFast(lowerCamelCase__ , do_lower_case=lowerCamelCase__ , split_by_punct=lowerCamelCase__) SCREAMING_SNAKE_CASE_ : int = rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCamelCase__ , add_special_tokens=lowerCamelCase__)) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) def _SCREAMING_SNAKE_CASE ( self : Tuple): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = '''I was born in 92000, and this is falsé.''' SCREAMING_SNAKE_CASE_ : Any = ['''▁''', '''<unk>''', '''▁was''', '''▁born''', '''▁in''', '''▁9''', '''2000''', '''▁''', ''',''', '''▁and''', '''▁this''', '''▁is''', '''▁fal''', '''s''', '''<unk>''', '''▁''', '''.''', ] # fmt: on SCREAMING_SNAKE_CASE_ : Tuple = DebertaVaTokenizer(lowerCamelCase__ , do_lower_case=lowerCamelCase__ , split_by_punct=lowerCamelCase__) SCREAMING_SNAKE_CASE_ : int = tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCamelCase__ , add_special_tokens=lowerCamelCase__)) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) SCREAMING_SNAKE_CASE_ : str = DebertaVaTokenizerFast(lowerCamelCase__ , do_lower_case=lowerCamelCase__ , split_by_punct=lowerCamelCase__) SCREAMING_SNAKE_CASE_ : int = rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCamelCase__ , add_special_tokens=lowerCamelCase__)) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = ''' \tHeLLo!how \n Are yoU? ''' SCREAMING_SNAKE_CASE_ : List[str] = ['''▁''', '''<unk>''', '''e''', '''<unk>''', '''o''', '''!''', '''how''', '''▁''', '''<unk>''', '''re''', '''▁yo''', '''<unk>''', '''?'''] # fmt: on SCREAMING_SNAKE_CASE_ : Union[str, Any] = DebertaVaTokenizer(lowerCamelCase__ , do_lower_case=lowerCamelCase__ , split_by_punct=lowerCamelCase__) SCREAMING_SNAKE_CASE_ : Optional[int] = tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCamelCase__ , add_special_tokens=lowerCamelCase__)) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) SCREAMING_SNAKE_CASE_ : Optional[int] = DebertaVaTokenizerFast(lowerCamelCase__ , do_lower_case=lowerCamelCase__ , split_by_punct=lowerCamelCase__) SCREAMING_SNAKE_CASE_ : Dict = rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCamelCase__ , add_special_tokens=lowerCamelCase__)) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : Dict = self.get_rust_tokenizer() SCREAMING_SNAKE_CASE_ : str = '''I was born in 92000, and this is falsé.''' SCREAMING_SNAKE_CASE_ : Tuple = tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCamelCase__ , add_special_tokens=lowerCamelCase__)) SCREAMING_SNAKE_CASE_ : Any = rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCamelCase__ , add_special_tokens=lowerCamelCase__)) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) SCREAMING_SNAKE_CASE_ : str = tokenizer.encode(lowerCamelCase__ , add_special_tokens=lowerCamelCase__) SCREAMING_SNAKE_CASE_ : int = rust_tokenizer.encode(lowerCamelCase__ , add_special_tokens=lowerCamelCase__) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) SCREAMING_SNAKE_CASE_ : int = self.get_rust_tokenizer() SCREAMING_SNAKE_CASE_ : Optional[Any] = tokenizer.encode(lowerCamelCase__) SCREAMING_SNAKE_CASE_ : Tuple = rust_tokenizer.encode(lowerCamelCase__) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) def _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = '''This is a test''' SCREAMING_SNAKE_CASE_ : List[str] = [13, 1, 4398, 25, 21, 1289] SCREAMING_SNAKE_CASE_ : int = ['''▁''', '''T''', '''his''', '''▁is''', '''▁a''', '''▁test'''] SCREAMING_SNAKE_CASE_ : Optional[Any] = ['''▁''', '''<unk>''', '''his''', '''▁is''', '''▁a''', '''▁test'''] SCREAMING_SNAKE_CASE_ : List[Any] = DebertaVaTokenizer(lowerCamelCase__ , keep_accents=lowerCamelCase__) SCREAMING_SNAKE_CASE_ : List[str] = DebertaVaTokenizerFast(lowerCamelCase__ , keep_accents=lowerCamelCase__) SCREAMING_SNAKE_CASE_ : Optional[Any] = tokenizer.encode(lowerCamelCase__ , add_special_tokens=lowerCamelCase__) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) SCREAMING_SNAKE_CASE_ : List[str] = tokenizer.tokenize(lowerCamelCase__) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) SCREAMING_SNAKE_CASE_ : Union[str, Any] = tokenizer.convert_ids_to_tokens(lowerCamelCase__) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) SCREAMING_SNAKE_CASE_ : int = rust_tokenizer.encode(lowerCamelCase__ , add_special_tokens=lowerCamelCase__) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) SCREAMING_SNAKE_CASE_ : Any = rust_tokenizer.tokenize(lowerCamelCase__) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) SCREAMING_SNAKE_CASE_ : int = rust_tokenizer.convert_ids_to_tokens(lowerCamelCase__) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) # fmt: off SCREAMING_SNAKE_CASE_ : Optional[Any] = '''I was born in 92000, and this is falsé.''' SCREAMING_SNAKE_CASE_ : str = [13, 1, 23, 386, 19, 561, 3050, 15, 17, 48, 25, 8256, 18, 1, 9] SCREAMING_SNAKE_CASE_ : Dict = ['''▁''', '''I''', '''▁was''', '''▁born''', '''▁in''', '''▁9''', '''2000''', ''',''', '''▁and''', '''▁this''', '''▁is''', '''▁fal''', '''s''', '''é''', '''.''', ] SCREAMING_SNAKE_CASE_ : Any = ['''▁''', '''<unk>''', '''▁was''', '''▁born''', '''▁in''', '''▁9''', '''2000''', ''',''', '''▁and''', '''▁this''', '''▁is''', '''▁fal''', '''s''', '''<unk>''', '''.''', ] # fmt: on SCREAMING_SNAKE_CASE_ : List[str] = tokenizer.encode(lowerCamelCase__ , add_special_tokens=lowerCamelCase__) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) SCREAMING_SNAKE_CASE_ : Union[str, Any] = tokenizer.tokenize(lowerCamelCase__) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) SCREAMING_SNAKE_CASE_ : Optional[int] = tokenizer.convert_ids_to_tokens(lowerCamelCase__) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) SCREAMING_SNAKE_CASE_ : Dict = rust_tokenizer.encode(lowerCamelCase__ , add_special_tokens=lowerCamelCase__) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) SCREAMING_SNAKE_CASE_ : List[Any] = rust_tokenizer.tokenize(lowerCamelCase__) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) SCREAMING_SNAKE_CASE_ : str = rust_tokenizer.convert_ids_to_tokens(lowerCamelCase__) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__) def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = DebertaVaTokenizer(lowerCamelCase__) SCREAMING_SNAKE_CASE_ : Any = tokenizer.encode('''sequence builders''') SCREAMING_SNAKE_CASE_ : Optional[int] = tokenizer.encode('''multi-sequence build''') SCREAMING_SNAKE_CASE_ : Dict = tokenizer.build_inputs_with_special_tokens(lowerCamelCase__) SCREAMING_SNAKE_CASE_ : Union[str, Any] = tokenizer.build_inputs_with_special_tokens(lowerCamelCase__ , lowerCamelCase__) self.assertEqual([tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] , lowerCamelCase__) self.assertEqual( [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [tokenizer.sep_token_id] , lowerCamelCase__ , ) @slow def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[str] = {'''input_ids''': [[1, 39867, 36, 19390, 486, 27, 35052, 81436, 18, 60685, 1225, 7, 35052, 81436, 18, 9367, 16899, 18, 15937, 53, 594, 773, 18, 16287, 30465, 36, 15937, 6, 41139, 38, 36979, 60763, 191, 6, 34132, 99, 6, 50538, 390, 43230, 6, 34132, 2779, 20850, 14, 699, 1072, 1194, 36, 382, 10901, 53, 7, 699, 1072, 2084, 36, 20422, 630, 53, 19, 105, 3049, 1896, 1053, 16899, 1506, 11, 37978, 4243, 7, 1237, 31869, 200, 16566, 654, 6, 35052, 81436, 7, 55630, 13593, 4, 2], [1, 26, 15011, 13, 667, 8, 1053, 18, 23611, 1237, 72356, 12820, 34, 104134, 1209, 35, 13313, 6627, 21, 202, 347, 7, 164, 2399, 11, 46, 4485, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 5, 1232, 2864, 15785, 14951, 105, 5, 8581, 1250, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], '''token_type_ids''': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], '''attention_mask''': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]} # noqa: E501 # fmt: on self.tokenizer_integration_test_util( expected_encoding=lowerCamelCase__ , model_name='''microsoft/deberta-v2-xlarge''' , revision='''ad6e42c1532ddf3a15c39246b63f5559d558b670''' , )
357
"""simple docstring""" from ...processing_utils import ProcessorMixin class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = "SpeechT5FeatureExtractor" __UpperCamelCase = "SpeechT5Tokenizer" def __init__( self : Any , lowercase_ : Dict , lowercase_ : Optional[Any]): '''simple docstring''' super().__init__(lowercase_ , lowercase_) def __call__( self : List[Any] , *lowercase_ : List[Any] , **lowercase_ : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[str] = kwargs.pop('''audio''' , lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = kwargs.pop('''text''' , lowercase_) SCREAMING_SNAKE_CASE_ : Any = kwargs.pop('''text_target''' , lowercase_) SCREAMING_SNAKE_CASE_ : Dict = kwargs.pop('''audio_target''' , lowercase_) SCREAMING_SNAKE_CASE_ : List[Any] = kwargs.pop('''sampling_rate''' , lowercase_) if audio is not None and text is not None: raise ValueError( '''Cannot process both `audio` and `text` inputs. Did you mean `audio_target` or `text_target`?''') if audio_target is not None and text_target is not None: raise ValueError( '''Cannot process both `audio_target` and `text_target` inputs. Did you mean `audio` or `text`?''') if audio is None and audio_target is None and text is None and text_target is None: raise ValueError( '''You need to specify either an `audio`, `audio_target`, `text`, or `text_target` input to process.''') if audio is not None: SCREAMING_SNAKE_CASE_ : Any = self.feature_extractor(lowercase_ , *lowercase_ , sampling_rate=lowercase_ , **lowercase_) elif text is not None: SCREAMING_SNAKE_CASE_ : Dict = self.tokenizer(lowercase_ , **lowercase_) else: SCREAMING_SNAKE_CASE_ : Any = None if audio_target is not None: SCREAMING_SNAKE_CASE_ : List[Any] = self.feature_extractor(audio_target=lowercase_ , *lowercase_ , sampling_rate=lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = targets['''input_values'''] elif text_target is not None: SCREAMING_SNAKE_CASE_ : int = self.tokenizer(lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : List[Any] = targets['''input_ids'''] else: SCREAMING_SNAKE_CASE_ : int = None if inputs is None: return targets if targets is not None: SCREAMING_SNAKE_CASE_ : Union[str, Any] = labels SCREAMING_SNAKE_CASE_ : Optional[Any] = targets.get('''attention_mask''') if decoder_attention_mask is not None: SCREAMING_SNAKE_CASE_ : Any = decoder_attention_mask return inputs def _SCREAMING_SNAKE_CASE ( self : Tuple , *lowercase_ : Tuple , **lowercase_ : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = kwargs.pop('''input_values''' , lowercase_) SCREAMING_SNAKE_CASE_ : int = kwargs.pop('''input_ids''' , lowercase_) SCREAMING_SNAKE_CASE_ : Dict = kwargs.pop('''labels''' , lowercase_) if input_values is not None and input_ids is not None: raise ValueError('''Cannot process both `input_values` and `input_ids` inputs.''') if input_values is None and input_ids is None and labels is None: raise ValueError( '''You need to specify either an `input_values`, `input_ids`, or `labels` input to be padded.''') if input_values is not None: SCREAMING_SNAKE_CASE_ : Any = self.feature_extractor.pad(lowercase_ , *lowercase_ , **lowercase_) elif input_ids is not None: SCREAMING_SNAKE_CASE_ : Tuple = self.tokenizer.pad(lowercase_ , **lowercase_) else: SCREAMING_SNAKE_CASE_ : List[Any] = None if labels is not None: if "input_ids" in labels or (isinstance(lowercase_ , lowercase_) and "input_ids" in labels[0]): SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.tokenizer.pad(lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : Dict = targets['''input_ids'''] else: SCREAMING_SNAKE_CASE_ : Dict = self.feature_extractor.feature_size SCREAMING_SNAKE_CASE_ : Optional[int] = self.feature_extractor.num_mel_bins SCREAMING_SNAKE_CASE_ : str = self.feature_extractor.pad(lowercase_ , *lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : str = feature_size_hack SCREAMING_SNAKE_CASE_ : Dict = targets['''input_values'''] else: SCREAMING_SNAKE_CASE_ : List[Any] = None if inputs is None: return targets if targets is not None: SCREAMING_SNAKE_CASE_ : Dict = labels SCREAMING_SNAKE_CASE_ : List[str] = targets.get('''attention_mask''') if decoder_attention_mask is not None: SCREAMING_SNAKE_CASE_ : Optional[Any] = decoder_attention_mask return inputs def _SCREAMING_SNAKE_CASE ( self : Optional[Any] , *lowercase_ : Optional[int] , **lowercase_ : Tuple): '''simple docstring''' return self.tokenizer.batch_decode(*lowercase_ , **lowercase_) def _SCREAMING_SNAKE_CASE ( self : List[Any] , *lowercase_ : Dict , **lowercase_ : List[Any]): '''simple docstring''' return self.tokenizer.decode(*lowercase_ , **lowercase_)
318
0
"""simple docstring""" UpperCAmelCase_ : Any = '''Tobias Carryer''' from time import time class lowerCAmelCase__ : '''simple docstring''' def __init__( self : Tuple , lowercase_ : List[Any] , lowercase_ : int , lowercase_ : Optional[Any] , lowercase_ : Dict=int(time())): # noqa: B008 '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[str] = multiplier SCREAMING_SNAKE_CASE_ : int = increment SCREAMING_SNAKE_CASE_ : str = modulo SCREAMING_SNAKE_CASE_ : Optional[Any] = seed def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = (self.multiplier * self.seed + self.increment) % self.modulo return self.seed if __name__ == "__main__": # Show the LCG in action. UpperCAmelCase_ : Tuple = LinearCongruentialGenerator(1664525, 1013904223, 2 << 31) while True: print(lcg.next_number())
358
"""simple docstring""" import os from typing import BinaryIO, Optional, Union import numpy as np import pyarrow.parquet as pq from .. import Audio, Dataset, Features, Image, NamedSplit, Value, config from ..features.features import FeatureType, _visit from ..formatting import query_table from ..packaged_modules import _PACKAGED_DATASETS_MODULES from ..packaged_modules.parquet.parquet import Parquet from ..utils import logging from ..utils.typing import NestedDataStructureLike, PathLike from .abc import AbstractDatasetReader def _A (__a ) -> Optional[int]: """simple docstring""" SCREAMING_SNAKE_CASE_ : List[str] = np.inf def set_batch_size(__a ) -> None: nonlocal batch_size if isinstance(__a , __a ): SCREAMING_SNAKE_CASE_ : Tuple = min(__a , config.PARQUET_ROW_GROUP_SIZE_FOR_IMAGE_DATASETS ) elif isinstance(__a , __a ): SCREAMING_SNAKE_CASE_ : int = min(__a , config.PARQUET_ROW_GROUP_SIZE_FOR_AUDIO_DATASETS ) elif isinstance(__a , __a ) and feature.dtype == "binary": SCREAMING_SNAKE_CASE_ : Union[str, Any] = min(__a , config.PARQUET_ROW_GROUP_SIZE_FOR_BINARY_DATASETS ) _visit(__a , __a ) return None if batch_size is np.inf else batch_size class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def __init__( self : Any , lowercase_ : NestedDataStructureLike[PathLike] , lowercase_ : Optional[NamedSplit] = None , lowercase_ : Optional[Features] = None , lowercase_ : str = None , lowercase_ : bool = False , lowercase_ : bool = False , lowercase_ : Optional[int] = None , **lowercase_ : Optional[int] , ): '''simple docstring''' super().__init__( lowercase_ , split=lowercase_ , features=lowercase_ , cache_dir=lowercase_ , keep_in_memory=lowercase_ , streaming=lowercase_ , num_proc=lowercase_ , **lowercase_ , ) SCREAMING_SNAKE_CASE_ : Any = path_or_paths if isinstance(lowercase_ , lowercase_) else {self.split: path_or_paths} SCREAMING_SNAKE_CASE_ : Any = _PACKAGED_DATASETS_MODULES['''parquet'''][1] SCREAMING_SNAKE_CASE_ : Union[str, Any] = Parquet( cache_dir=lowercase_ , data_files=lowercase_ , features=lowercase_ , hash=lowercase_ , **lowercase_ , ) def _SCREAMING_SNAKE_CASE ( self : Tuple): '''simple docstring''' if self.streaming: SCREAMING_SNAKE_CASE_ : str = self.builder.as_streaming_dataset(split=self.split) # Build regular (map-style) dataset else: SCREAMING_SNAKE_CASE_ : Optional[Any] = None SCREAMING_SNAKE_CASE_ : Optional[int] = None SCREAMING_SNAKE_CASE_ : Tuple = None SCREAMING_SNAKE_CASE_ : Dict = None self.builder.download_and_prepare( download_config=lowercase_ , download_mode=lowercase_ , verification_mode=lowercase_ , base_path=lowercase_ , num_proc=self.num_proc , ) SCREAMING_SNAKE_CASE_ : Any = self.builder.as_dataset( split=self.split , verification_mode=lowercase_ , in_memory=self.keep_in_memory) return dataset class lowerCAmelCase__ : '''simple docstring''' def __init__( self : Tuple , lowercase_ : Dataset , lowercase_ : Union[PathLike, BinaryIO] , lowercase_ : Optional[int] = None , **lowercase_ : Dict , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = dataset SCREAMING_SNAKE_CASE_ : Dict = path_or_buf SCREAMING_SNAKE_CASE_ : List[Any] = batch_size or get_writer_batch_size(dataset.features) SCREAMING_SNAKE_CASE_ : Any = parquet_writer_kwargs def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[str] = self.batch_size if self.batch_size else config.DEFAULT_MAX_BATCH_SIZE if isinstance(self.path_or_buf , (str, bytes, os.PathLike)): with open(self.path_or_buf , '''wb+''') as buffer: SCREAMING_SNAKE_CASE_ : Optional[Any] = self._write(file_obj=lowercase_ , batch_size=lowercase_ , **self.parquet_writer_kwargs) else: SCREAMING_SNAKE_CASE_ : str = self._write(file_obj=self.path_or_buf , batch_size=lowercase_ , **self.parquet_writer_kwargs) return written def _SCREAMING_SNAKE_CASE ( self : Tuple , lowercase_ : BinaryIO , lowercase_ : int , **lowercase_ : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = 0 SCREAMING_SNAKE_CASE_ : Optional[int] = parquet_writer_kwargs.pop('''path_or_buf''' , lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = self.dataset.features.arrow_schema SCREAMING_SNAKE_CASE_ : Tuple = pq.ParquetWriter(lowercase_ , schema=lowercase_ , **lowercase_) for offset in logging.tqdm( range(0 , len(self.dataset) , lowercase_) , unit='''ba''' , disable=not logging.is_progress_bar_enabled() , desc='''Creating parquet from Arrow format''' , ): SCREAMING_SNAKE_CASE_ : List[Any] = query_table( table=self.dataset._data , key=slice(lowercase_ , offset + batch_size) , indices=self.dataset._indices if self.dataset._indices is not None else None , ) writer.write_table(lowercase_) written += batch.nbytes writer.close() return written
318
0
"""simple docstring""" def _A (__a ) -> Any: """simple docstring""" if not isinstance(_lowercase , _lowercase ): raise ValueError('''Input series is not valid, valid series - [2, 4, 6]''' ) if len(_lowercase ) == 0: raise ValueError('''Input list must be a non empty list''' ) if len(_lowercase ) == 1: return True SCREAMING_SNAKE_CASE_ : int = series[1] - series[0] for index in range(len(_lowercase ) - 1 ): if series[index + 1] - series[index] != common_diff: return False return True def _A (__a ) -> Optional[Any]: """simple docstring""" if not isinstance(_lowercase , _lowercase ): raise ValueError('''Input series is not valid, valid series - [2, 4, 6]''' ) if len(_lowercase ) == 0: raise ValueError('''Input list must be a non empty list''' ) SCREAMING_SNAKE_CASE_ : Dict = 0 for val in series: answer += val return answer / len(_lowercase ) if __name__ == "__main__": import doctest doctest.testmod()
359
"""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() UpperCAmelCase_ : str = logging.get_logger(__name__) UpperCAmelCase_ : Optional[Any] = ["""model.decoder.embed_positions.weights"""] def _A (__a ) -> Dict: """simple docstring""" if "emb" in name: SCREAMING_SNAKE_CASE_ : Optional[int] = name.replace('''emb''' , '''model.decoder.embed_tokens''' ) if "transformer" in name: SCREAMING_SNAKE_CASE_ : Tuple = name.replace('''transformer''' , '''model.decoder''' ) if "cross_attention" in name: SCREAMING_SNAKE_CASE_ : str = name.replace('''cross_attention''' , '''encoder_attn''' ) if "linear1" in name: SCREAMING_SNAKE_CASE_ : Optional[int] = name.replace('''linear1''' , '''fc1''' ) if "linear2" in name: SCREAMING_SNAKE_CASE_ : str = name.replace('''linear2''' , '''fc2''' ) if "norm1" in name: SCREAMING_SNAKE_CASE_ : Any = name.replace('''norm1''' , '''self_attn_layer_norm''' ) if "norm_cross" in name: SCREAMING_SNAKE_CASE_ : List[str] = name.replace('''norm_cross''' , '''encoder_attn_layer_norm''' ) if "norm2" in name: SCREAMING_SNAKE_CASE_ : Tuple = name.replace('''norm2''' , '''final_layer_norm''' ) if "out_norm" in name: SCREAMING_SNAKE_CASE_ : List[str] = name.replace('''out_norm''' , '''model.decoder.layer_norm''' ) if "linears" in name: SCREAMING_SNAKE_CASE_ : Dict = name.replace('''linears''' , '''lm_heads''' ) if "condition_provider.conditioners.description.output_proj" in name: SCREAMING_SNAKE_CASE_ : List[str] = name.replace('''condition_provider.conditioners.description.output_proj''' , '''enc_to_dec_proj''' ) return name def _A (__a , __a ) -> Tuple[Dict, Dict]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Union[str, Any] = list(state_dict.keys() ) SCREAMING_SNAKE_CASE_ : int = {} for key in keys: SCREAMING_SNAKE_CASE_ : int = state_dict.pop(__a ) SCREAMING_SNAKE_CASE_ : int = rename_keys(__a ) if "in_proj_weight" in key: # split fused qkv proj SCREAMING_SNAKE_CASE_ : List[str] = val[:hidden_size, :] SCREAMING_SNAKE_CASE_ : List[str] = val[hidden_size : 2 * hidden_size, :] SCREAMING_SNAKE_CASE_ : Optional[Any] = val[-hidden_size:, :] elif "enc_to_dec_proj" in key: SCREAMING_SNAKE_CASE_ : int = val else: SCREAMING_SNAKE_CASE_ : Any = val return state_dict, enc_dec_proj_state_dict def _A (__a ) -> MusicgenDecoderConfig: """simple docstring""" if checkpoint == "small": # default config values SCREAMING_SNAKE_CASE_ : Optional[int] = 10_24 SCREAMING_SNAKE_CASE_ : Tuple = 24 SCREAMING_SNAKE_CASE_ : Optional[Any] = 16 elif checkpoint == "medium": SCREAMING_SNAKE_CASE_ : List[str] = 15_36 SCREAMING_SNAKE_CASE_ : Optional[int] = 48 SCREAMING_SNAKE_CASE_ : Optional[int] = 24 elif checkpoint == "large": SCREAMING_SNAKE_CASE_ : Optional[Any] = 20_48 SCREAMING_SNAKE_CASE_ : Optional[int] = 48 SCREAMING_SNAKE_CASE_ : int = 32 else: raise ValueError(f'Checkpoint should be one of `[\'small\', \'medium\', \'large\']`, got {checkpoint}.' ) SCREAMING_SNAKE_CASE_ : List[Any] = MusicgenDecoderConfig( hidden_size=__a , ffn_dim=hidden_size * 4 , num_hidden_layers=__a , num_attention_heads=__a , ) return config @torch.no_grad() def _A (__a , __a=None , __a=None , __a="cpu" ) -> List[str]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Any = MusicGen.get_pretrained(__a , device=__a ) SCREAMING_SNAKE_CASE_ : Dict = decoder_config_from_checkpoint(__a ) SCREAMING_SNAKE_CASE_ : Optional[Any] = fairseq_model.lm.state_dict() SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : int = rename_state_dict( __a , hidden_size=decoder_config.hidden_size ) SCREAMING_SNAKE_CASE_ : Optional[Any] = TaEncoderModel.from_pretrained('''t5-base''' ) SCREAMING_SNAKE_CASE_ : List[str] = EncodecModel.from_pretrained('''facebook/encodec_32khz''' ) SCREAMING_SNAKE_CASE_ : int = MusicgenForCausalLM(__a ).eval() # load all decoder weights - expect that we'll be missing embeddings and enc-dec projection SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : List[str] = decoder.load_state_dict(__a , strict=__a ) for key in missing_keys.copy(): if key.startswith(('''text_encoder''', '''audio_encoder''') ) or key in EXPECTED_MISSING_KEYS: missing_keys.remove(__a ) if len(__a ) > 0: raise ValueError(f'Missing key(s) in state_dict: {missing_keys}' ) if len(__a ) > 0: raise ValueError(f'Unexpected key(s) in state_dict: {unexpected_keys}' ) # init the composite model SCREAMING_SNAKE_CASE_ : str = MusicgenForConditionalGeneration(text_encoder=__a , audio_encoder=__a , decoder=__a ) # load the pre-trained enc-dec projection (from the decoder state dict) model.enc_to_dec_proj.load_state_dict(__a ) # check we can do a forward pass SCREAMING_SNAKE_CASE_ : Dict = torch.arange(0 , 8 , dtype=torch.long ).reshape(2 , -1 ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = input_ids.reshape(2 * 4 , -1 ) with torch.no_grad(): SCREAMING_SNAKE_CASE_ : List[Any] = model(input_ids=__a , decoder_input_ids=__a ).logits if logits.shape != (8, 1, 20_48): raise ValueError('''Incorrect shape for logits''' ) # now construct the processor SCREAMING_SNAKE_CASE_ : str = AutoTokenizer.from_pretrained('''t5-base''' ) SCREAMING_SNAKE_CASE_ : str = AutoFeatureExtractor.from_pretrained('''facebook/encodec_32khz''' , padding_side='''left''' ) SCREAMING_SNAKE_CASE_ : Tuple = MusicgenProcessor(feature_extractor=__a , tokenizer=__a ) # set the appropriate bos/pad token ids SCREAMING_SNAKE_CASE_ : str = 20_48 SCREAMING_SNAKE_CASE_ : List[Any] = 20_48 # set other default generation config params SCREAMING_SNAKE_CASE_ : int = int(30 * audio_encoder.config.frame_rate ) SCREAMING_SNAKE_CASE_ : str = True SCREAMING_SNAKE_CASE_ : Optional[Any] = 3.0 if pytorch_dump_folder is not None: Path(__a ).mkdir(exist_ok=__a ) logger.info(f'Saving model {checkpoint} to {pytorch_dump_folder}' ) model.save_pretrained(__a ) processor.save_pretrained(__a ) if repo_id: logger.info(f'Pushing model {checkpoint} to {repo_id}' ) model.push_to_hub(__a ) processor.push_to_hub(__a ) if __name__ == "__main__": UpperCAmelCase_ : Dict = 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.""" ) UpperCAmelCase_ : Dict = parser.parse_args() convert_musicgen_checkpoint(args.checkpoint, args.pytorch_dump_folder, args.push_to_hub)
318
0
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_torch_available, ) UpperCAmelCase_ : int = { "configuration_gpt_bigcode": ["GPT_BIGCODE_PRETRAINED_CONFIG_ARCHIVE_MAP", "GPTBigCodeConfig"], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase_ : List[Any] = [ "GPT_BIGCODE_PRETRAINED_MODEL_ARCHIVE_LIST", "GPTBigCodeForSequenceClassification", "GPTBigCodeForTokenClassification", "GPTBigCodeForCausalLM", "GPTBigCodeModel", "GPTBigCodePreTrainedModel", ] if TYPE_CHECKING: from .configuration_gpt_bigcode import GPT_BIGCODE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTBigCodeConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_gpt_bigcode import ( GPT_BIGCODE_PRETRAINED_MODEL_ARCHIVE_LIST, GPTBigCodeForCausalLM, GPTBigCodeForSequenceClassification, GPTBigCodeForTokenClassification, GPTBigCodeModel, GPTBigCodePreTrainedModel, ) else: import sys UpperCAmelCase_ : List[Any] = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
360
"""simple docstring""" from pathlib import Path import numpy as np from PIL import Image def _A (__a ) -> np.ndarray: """simple docstring""" SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Optional[int] = rgb[:, :, 0], rgb[:, :, 1], rgb[:, :, 2] return 0.29_89 * r + 0.58_70 * g + 0.11_40 * b def _A (__a ) -> np.ndarray: """simple docstring""" return (gray > 1_27) & (gray <= 2_55) def _A (__a , __a ) -> np.ndarray: """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[Any] = np.zeros_like(__a ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = np.zeros( (image.shape[0] + kernel.shape[0] - 1, image.shape[1] + kernel.shape[1] - 1) ) # Copy image to padded image SCREAMING_SNAKE_CASE_ : Union[str, Any] = image # Iterate over image & apply kernel for x in range(image.shape[1] ): for y in range(image.shape[0] ): SCREAMING_SNAKE_CASE_ : Optional[Any] = ( kernel * image_padded[y : y + kernel.shape[0], x : x + kernel.shape[1]] ).sum() SCREAMING_SNAKE_CASE_ : Any = int(summation > 0 ) return output if __name__ == "__main__": # read original image UpperCAmelCase_ : Dict = Path(__file__).resolve().parent / """image_data""" / """lena.jpg""" UpperCAmelCase_ : List[Any] = np.array(Image.open(lena_path)) # kernel to be applied UpperCAmelCase_ : Any = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]]) UpperCAmelCase_ : Tuple = dilation(gray_to_binary(rgb_to_gray(lena)), structuring_element) # Save the output image UpperCAmelCase_ : List[str] = Image.fromarray(output).convert("""RGB""") pil_img.save("""result_dilation.png""")
318
0
"""simple docstring""" from collections import OrderedDict from typing import Mapping from packaging import version from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging UpperCAmelCase_ = logging.get_logger(__name__) UpperCAmelCase_ = { """facebook/data2vec-vision-base-ft""": ( """https://huggingface.co/facebook/data2vec-vision-base-ft/resolve/main/config.json""" ), } class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = "data2vec-vision" def __init__( self : List[str] , lowercase_ : int=768 , lowercase_ : int=12 , lowercase_ : Union[str, Any]=12 , lowercase_ : Dict=3072 , lowercase_ : str="gelu" , lowercase_ : Dict=0.0 , lowercase_ : Dict=0.0 , lowercase_ : Union[str, Any]=0.02 , lowercase_ : List[str]=1e-12 , lowercase_ : Any=224 , lowercase_ : Any=16 , lowercase_ : Dict=3 , lowercase_ : Tuple=False , lowercase_ : Union[str, Any]=False , lowercase_ : Optional[int]=False , lowercase_ : int=False , lowercase_ : Any=0.1 , lowercase_ : int=0.1 , lowercase_ : int=True , lowercase_ : Union[str, Any]=[3, 5, 7, 11] , lowercase_ : Tuple=[1, 2, 3, 6] , lowercase_ : int=True , lowercase_ : Tuple=0.4 , lowercase_ : Optional[Any]=256 , lowercase_ : Tuple=1 , lowercase_ : List[str]=False , lowercase_ : List[Any]=255 , **lowercase_ : Tuple , ): '''simple docstring''' super().__init__(**lowerCamelCase_) SCREAMING_SNAKE_CASE_ : str = hidden_size SCREAMING_SNAKE_CASE_ : Union[str, Any] = num_hidden_layers SCREAMING_SNAKE_CASE_ : str = num_attention_heads SCREAMING_SNAKE_CASE_ : Union[str, Any] = intermediate_size SCREAMING_SNAKE_CASE_ : Optional[int] = hidden_act SCREAMING_SNAKE_CASE_ : Optional[int] = hidden_dropout_prob SCREAMING_SNAKE_CASE_ : Any = attention_probs_dropout_prob SCREAMING_SNAKE_CASE_ : Dict = initializer_range SCREAMING_SNAKE_CASE_ : List[str] = layer_norm_eps SCREAMING_SNAKE_CASE_ : Any = image_size SCREAMING_SNAKE_CASE_ : Optional[Any] = patch_size SCREAMING_SNAKE_CASE_ : str = num_channels SCREAMING_SNAKE_CASE_ : Optional[Any] = use_mask_token SCREAMING_SNAKE_CASE_ : List[str] = use_absolute_position_embeddings SCREAMING_SNAKE_CASE_ : int = use_relative_position_bias SCREAMING_SNAKE_CASE_ : Dict = use_shared_relative_position_bias SCREAMING_SNAKE_CASE_ : Union[str, Any] = layer_scale_init_value SCREAMING_SNAKE_CASE_ : int = drop_path_rate SCREAMING_SNAKE_CASE_ : Any = use_mean_pooling # decode head attributes (semantic segmentation) SCREAMING_SNAKE_CASE_ : Tuple = out_indices SCREAMING_SNAKE_CASE_ : Optional[int] = pool_scales # auxiliary head attributes (semantic segmentation) SCREAMING_SNAKE_CASE_ : str = use_auxiliary_head SCREAMING_SNAKE_CASE_ : Tuple = auxiliary_loss_weight SCREAMING_SNAKE_CASE_ : Optional[int] = auxiliary_channels SCREAMING_SNAKE_CASE_ : Dict = auxiliary_num_convs SCREAMING_SNAKE_CASE_ : List[Any] = auxiliary_concat_input SCREAMING_SNAKE_CASE_ : Optional[Any] = semantic_loss_ignore_index class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = version.parse("1.11" ) @property def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' return OrderedDict( [ ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}), ]) @property def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' return 1e-4
361
"""simple docstring""" from collections import defaultdict def _A (__a , __a ) -> bool: """simple docstring""" SCREAMING_SNAKE_CASE_ : Dict = first_str.lower().strip() SCREAMING_SNAKE_CASE_ : List[Any] = second_str.lower().strip() # Remove whitespace SCREAMING_SNAKE_CASE_ : Dict = first_str.replace(''' ''' , '''''' ) SCREAMING_SNAKE_CASE_ : Optional[Any] = second_str.replace(''' ''' , '''''' ) # Strings of different lengths are not anagrams if len(__a ) != len(__a ): return False # Default values for count should be 0 SCREAMING_SNAKE_CASE_ : defaultdict[str, int] = defaultdict(__a ) # For each character in input strings, # increment count in the corresponding for i in range(len(__a ) ): count[first_str[i]] += 1 count[second_str[i]] -= 1 return all(_count == 0 for _count in count.values() ) if __name__ == "__main__": from doctest import testmod testmod() UpperCAmelCase_ : Any = input("""Enter the first string """).strip() UpperCAmelCase_ : Optional[int] = input("""Enter the second string """).strip() UpperCAmelCase_ : Union[str, Any] = check_anagrams(input_a, input_b) print(f'''{input_a} and {input_b} are {'' if status else 'not '}anagrams.''')
318
0
"""simple docstring""" import inspect import unittest from math import floor from transformers import CvtConfig from transformers.file_utils import cached_property, is_torch_available, is_vision_available from transformers.testing_utils import require_torch, require_vision, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import CvtForImageClassification, CvtModel from transformers.models.cvt.modeling_cvt import CVT_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import AutoImageProcessor class lowerCAmelCase__ ( lowerCamelCase__ ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = self.config_class(**self.inputs_dict) self.parent.assertTrue(hasattr(snake_case__ , '''embed_dim''')) self.parent.assertTrue(hasattr(snake_case__ , '''num_heads''')) class lowerCAmelCase__ : '''simple docstring''' def __init__( self : Optional[Any] , lowercase_ : Optional[int] , lowercase_ : Tuple=13 , lowercase_ : Optional[Any]=64 , lowercase_ : Optional[int]=3 , lowercase_ : Any=[16, 48, 96] , lowercase_ : List[str]=[1, 3, 6] , lowercase_ : int=[1, 2, 10] , lowercase_ : Optional[Any]=[7, 3, 3] , lowercase_ : List[Any]=[4, 2, 2] , lowercase_ : Optional[int]=[2, 1, 1] , lowercase_ : int=[2, 2, 2] , lowercase_ : Any=[False, False, True] , lowercase_ : Union[str, Any]=[0.0, 0.0, 0.0] , lowercase_ : Optional[int]=0.02 , lowercase_ : int=1e-12 , lowercase_ : List[Any]=True , lowercase_ : str=True , lowercase_ : Any=2 , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = parent SCREAMING_SNAKE_CASE_ : int = batch_size SCREAMING_SNAKE_CASE_ : int = image_size SCREAMING_SNAKE_CASE_ : Union[str, Any] = patch_sizes SCREAMING_SNAKE_CASE_ : int = patch_stride SCREAMING_SNAKE_CASE_ : Optional[Any] = patch_padding SCREAMING_SNAKE_CASE_ : List[str] = is_training SCREAMING_SNAKE_CASE_ : Optional[int] = use_labels SCREAMING_SNAKE_CASE_ : List[str] = num_labels SCREAMING_SNAKE_CASE_ : int = num_channels SCREAMING_SNAKE_CASE_ : List[str] = embed_dim SCREAMING_SNAKE_CASE_ : str = num_heads SCREAMING_SNAKE_CASE_ : Union[str, Any] = stride_kv SCREAMING_SNAKE_CASE_ : int = depth SCREAMING_SNAKE_CASE_ : Dict = cls_token SCREAMING_SNAKE_CASE_ : int = attention_drop_rate SCREAMING_SNAKE_CASE_ : int = initializer_range SCREAMING_SNAKE_CASE_ : Union[str, Any] = layer_norm_eps def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]) SCREAMING_SNAKE_CASE_ : int = None if self.use_labels: SCREAMING_SNAKE_CASE_ : List[str] = ids_tensor([self.batch_size] , self.num_labels) SCREAMING_SNAKE_CASE_ : Any = self.get_config() return config, pixel_values, labels def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' return CvtConfig( image_size=self.image_size , num_labels=self.num_labels , num_channels=self.num_channels , embed_dim=self.embed_dim , num_heads=self.num_heads , patch_sizes=self.patch_sizes , patch_padding=self.patch_padding , patch_stride=self.patch_stride , stride_kv=self.stride_kv , depth=self.depth , cls_token=self.cls_token , attention_drop_rate=self.attention_drop_rate , initializer_range=self.initializer_range , ) def _SCREAMING_SNAKE_CASE ( self : Optional[Any] , lowercase_ : int , lowercase_ : Optional[Any] , lowercase_ : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = CvtModel(config=snake_case__) model.to(snake_case__) model.eval() SCREAMING_SNAKE_CASE_ : Optional[Any] = model(snake_case__) SCREAMING_SNAKE_CASE_ : Dict = (self.image_size, self.image_size) SCREAMING_SNAKE_CASE_ : Optional[int] = image_size[0], image_size[1] for i in range(len(self.depth)): SCREAMING_SNAKE_CASE_ : Any = floor(((height + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1) SCREAMING_SNAKE_CASE_ : str = floor(((width + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.embed_dim[-1], height, width)) def _SCREAMING_SNAKE_CASE ( self : Any , lowercase_ : List[str] , lowercase_ : Optional[int] , lowercase_ : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = self.num_labels SCREAMING_SNAKE_CASE_ : str = CvtForImageClassification(snake_case__) model.to(snake_case__) model.eval() SCREAMING_SNAKE_CASE_ : Dict = model(snake_case__ , labels=snake_case__) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels)) def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = self.prepare_config_and_inputs() SCREAMING_SNAKE_CASE_ : Optional[int] = config_and_inputs SCREAMING_SNAKE_CASE_ : Optional[Any] = {'''pixel_values''': pixel_values} return config, inputs_dict @require_torch class lowerCAmelCase__ ( lowerCamelCase__ , lowerCamelCase__ , unittest.TestCase ): '''simple docstring''' __UpperCamelCase = (CvtModel, CvtForImageClassification) if is_torch_available() else () __UpperCamelCase = ( {"""feature-extraction""": CvtModel, """image-classification""": CvtForImageClassification} if is_torch_available() else {} ) __UpperCamelCase = False __UpperCamelCase = False __UpperCamelCase = False __UpperCamelCase = False __UpperCamelCase = False def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = CvtModelTester(self) SCREAMING_SNAKE_CASE_ : Tuple = ConfigTester(self , config_class=snake_case__ , has_text_modality=snake_case__ , hidden_size=37) def _SCREAMING_SNAKE_CASE ( self : str): '''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 _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' return @unittest.skip(reason='''Cvt does not output attentions''') def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' pass @unittest.skip(reason='''Cvt does not use inputs_embeds''') def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' pass @unittest.skip(reason='''Cvt does not support input and output embeddings''') def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' pass def _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: SCREAMING_SNAKE_CASE_ : List[str] = model_class(snake_case__) SCREAMING_SNAKE_CASE_ : Dict = inspect.signature(model.forward) # signature.parameters is an OrderedDict => so arg_names order is deterministic SCREAMING_SNAKE_CASE_ : Dict = [*signature.parameters.keys()] SCREAMING_SNAKE_CASE_ : int = ['''pixel_values'''] self.assertListEqual(arg_names[:1] , snake_case__) def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*snake_case__) def _SCREAMING_SNAKE_CASE ( self : Any): '''simple docstring''' def check_hidden_states_output(lowercase_ : str , lowercase_ : Union[str, Any] , lowercase_ : Dict): SCREAMING_SNAKE_CASE_ : Tuple = model_class(snake_case__) model.to(snake_case__) model.eval() with torch.no_grad(): SCREAMING_SNAKE_CASE_ : str = model(**self._prepare_for_class(snake_case__ , snake_case__)) SCREAMING_SNAKE_CASE_ : List[str] = outputs.hidden_states SCREAMING_SNAKE_CASE_ : Tuple = len(self.model_tester.depth) self.assertEqual(len(snake_case__) , snake_case__) # verify the first hidden states (first block) self.assertListEqual( list(hidden_states[0].shape[-3:]) , [ self.model_tester.embed_dim[0], self.model_tester.image_size // 4, self.model_tester.image_size // 4, ] , ) SCREAMING_SNAKE_CASE_ : Any = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: SCREAMING_SNAKE_CASE_ : int = True check_hidden_states_output(snake_case__ , snake_case__ , snake_case__) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] SCREAMING_SNAKE_CASE_ : Optional[Any] = True check_hidden_states_output(snake_case__ , snake_case__ , snake_case__) def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*snake_case__) @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.''') def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' pass @slow def _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' for model_name in CVT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: SCREAMING_SNAKE_CASE_ : Tuple = CvtModel.from_pretrained(snake_case__) self.assertIsNotNone(snake_case__) def _A () -> str: """simple docstring""" SCREAMING_SNAKE_CASE_ : List[str] = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' ) return image @require_torch @require_vision class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' @cached_property def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' return AutoImageProcessor.from_pretrained(CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0]) @slow def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = CvtForImageClassification.from_pretrained(CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0]).to(snake_case__) SCREAMING_SNAKE_CASE_ : int = self.default_image_processor SCREAMING_SNAKE_CASE_ : int = prepare_img() SCREAMING_SNAKE_CASE_ : List[Any] = image_processor(images=snake_case__ , return_tensors='''pt''').to(snake_case__) # forward pass with torch.no_grad(): SCREAMING_SNAKE_CASE_ : int = model(**snake_case__) # verify the logits SCREAMING_SNAKE_CASE_ : str = torch.Size((1, 1000)) self.assertEqual(outputs.logits.shape , snake_case__) SCREAMING_SNAKE_CASE_ : List[str] = torch.tensor([0.92_85, 0.90_15, -0.31_50]).to(snake_case__) self.assertTrue(torch.allclose(outputs.logits[0, :3] , snake_case__ , atol=1e-4))
362
"""simple docstring""" import argparse from collections import defaultdict import yaml UpperCAmelCase_ : Optional[Any] = """docs/source/en/_toctree.yml""" def _A (__a ) -> Union[str, Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : str = defaultdict(__a ) for doc in model_doc: counts[doc["local"]] += 1 SCREAMING_SNAKE_CASE_ : List[Any] = [key for key, value in counts.items() if value > 1] SCREAMING_SNAKE_CASE_ : int = [] for duplicate_key in duplicates: SCREAMING_SNAKE_CASE_ : List[str] = list({doc['''title'''] for doc in model_doc if doc['''local'''] == duplicate_key} ) if len(__a ) > 1: raise ValueError( f'{duplicate_key} is present several times in the documentation table of content at ' '''`docs/source/en/_toctree.yml` with different *Title* values. Choose one of those and remove the ''' '''others.''' ) # Only add this once new_doc.append({'''local''': duplicate_key, '''title''': titles[0]} ) # Add none duplicate-keys new_doc.extend([doc for doc in model_doc if counts[doc['''local''']] == 1] ) # Sort return sorted(__a , key=lambda __a : s["title"].lower() ) def _A (__a=False ) -> Tuple: """simple docstring""" with open(__a , encoding='''utf-8''' ) as f: SCREAMING_SNAKE_CASE_ : Dict = yaml.safe_load(f.read() ) # Get to the API doc SCREAMING_SNAKE_CASE_ : Any = 0 while content[api_idx]["title"] != "API": api_idx += 1 SCREAMING_SNAKE_CASE_ : str = content[api_idx]['''sections'''] # Then to the model doc SCREAMING_SNAKE_CASE_ : List[Any] = 0 while api_doc[model_idx]["title"] != "Models": model_idx += 1 SCREAMING_SNAKE_CASE_ : Optional[int] = api_doc[model_idx]['''sections'''] SCREAMING_SNAKE_CASE_ : str = [(idx, section) for idx, section in enumerate(__a ) if '''sections''' in section] SCREAMING_SNAKE_CASE_ : Optional[Any] = False for idx, modality_doc in modalities_docs: SCREAMING_SNAKE_CASE_ : List[str] = modality_doc['''sections'''] SCREAMING_SNAKE_CASE_ : Union[str, Any] = clean_model_doc_toc(__a ) if old_modality_doc != new_modality_doc: SCREAMING_SNAKE_CASE_ : str = True if overwrite: SCREAMING_SNAKE_CASE_ : Optional[int] = new_modality_doc if diff: if overwrite: SCREAMING_SNAKE_CASE_ : List[Any] = model_doc SCREAMING_SNAKE_CASE_ : int = api_doc with open(__a , '''w''' , encoding='''utf-8''' ) as f: f.write(yaml.dump(__a , allow_unicode=__a ) ) else: raise ValueError( '''The model doc part of the table of content is not properly sorted, run `make style` to fix this.''' ) if __name__ == "__main__": UpperCAmelCase_ : List[str] = argparse.ArgumentParser() parser.add_argument("""--fix_and_overwrite""", action="""store_true""", help="""Whether to fix inconsistencies.""") UpperCAmelCase_ : Tuple = parser.parse_args() check_model_doc(args.fix_and_overwrite)
318
0
"""simple docstring""" import inspect import os import unittest from dataclasses import dataclass import torch from accelerate import Accelerator, DistributedDataParallelKwargs, GradScalerKwargs from accelerate.state import AcceleratorState from accelerate.test_utils import execute_subprocess_async, require_cuda, require_multi_gpu from accelerate.utils import KwargsHandler @dataclass class lowerCAmelCase__ ( a__ ): '''simple docstring''' __UpperCamelCase = 0 __UpperCamelCase = False __UpperCamelCase = 3.0 class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' self.assertDictEqual(MockClass().to_kwargs() , {}) self.assertDictEqual(MockClass(a=2).to_kwargs() , {'''a''': 2}) self.assertDictEqual(MockClass(a=2 , b=lowerCAmelCase__).to_kwargs() , {'''a''': 2, '''b''': True}) self.assertDictEqual(MockClass(a=2 , c=2.25).to_kwargs() , {'''a''': 2, '''c''': 2.25}) @require_cuda def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = GradScalerKwargs(init_scale=1024 , growth_factor=2) AcceleratorState._reset_state() SCREAMING_SNAKE_CASE_ : List[Any] = Accelerator(mixed_precision='''fp16''' , kwargs_handlers=[scaler_handler]) print(accelerator.use_fpaa) SCREAMING_SNAKE_CASE_ : int = accelerator.scaler # Check the kwargs have been applied self.assertEqual(scaler._init_scale , 1024.0) self.assertEqual(scaler._growth_factor , 2.0) # Check the other values are at the default self.assertEqual(scaler._backoff_factor , 0.5) self.assertEqual(scaler._growth_interval , 2000) self.assertEqual(scaler._enabled , lowerCAmelCase__) @require_multi_gpu def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = ["torchrun", F'--nproc_per_node={torch.cuda.device_count()}', inspect.getfile(self.__class__)] execute_subprocess_async(lowerCAmelCase__ , env=os.environ.copy()) if __name__ == "__main__": UpperCAmelCase_ : List[Any] = DistributedDataParallelKwargs(bucket_cap_mb=15, find_unused_parameters=True) UpperCAmelCase_ : List[str] = Accelerator(kwargs_handlers=[ddp_scaler]) UpperCAmelCase_ : Optional[int] = torch.nn.Linear(100, 200) UpperCAmelCase_ : int = accelerator.prepare(model) # Check the values changed in kwargs UpperCAmelCase_ : str = '''''' UpperCAmelCase_ : Dict = model.bucket_bytes_cap // (1024 * 1024) if observed_bucket_cap_map != 15: error_msg += f"Kwargs badly passed, should have `15` but found {observed_bucket_cap_map}.\n" if model.find_unused_parameters is not True: error_msg += f"Kwargs badly passed, should have `True` but found {model.find_unused_parameters}.\n" # Check the values of the defaults if model.dim != 0: error_msg += f"Default value not respected, should have `0` but found {model.dim}.\n" if model.broadcast_buffers is not True: error_msg += f"Default value not respected, should have `True` but found {model.broadcast_buffers}.\n" if model.gradient_as_bucket_view is not False: error_msg += f"Default value not respected, should have `False` but found {model.gradient_as_bucket_view}.\n" # Raise error at the end to make sure we don't stop at the first failure. if len(error_msg) > 0: raise ValueError(error_msg)
363
"""simple docstring""" from ...utils import ( OptionalDependencyNotAvailable, is_torch_available, is_transformers_available, is_transformers_version, ) try: if not (is_transformers_available() and is_torch_available() and is_transformers_version(""">=""", """4.25.0""")): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ...utils.dummy_torch_and_transformers_objects import ( VersatileDiffusionDualGuidedPipeline, VersatileDiffusionImageVariationPipeline, VersatileDiffusionPipeline, VersatileDiffusionTextToImagePipeline, ) else: from .modeling_text_unet import UNetFlatConditionModel from .pipeline_versatile_diffusion import VersatileDiffusionPipeline from .pipeline_versatile_diffusion_dual_guided import VersatileDiffusionDualGuidedPipeline from .pipeline_versatile_diffusion_image_variation import VersatileDiffusionImageVariationPipeline from .pipeline_versatile_diffusion_text_to_image import VersatileDiffusionTextToImagePipeline
318
0
"""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 lowerCAmelCase__ : '''simple docstring''' def __init__( self : Dict , lowercase_ : Optional[int] , lowercase_ : str=13 , lowercase_ : Any=7 , lowercase_ : Tuple=True , lowercase_ : Dict=True , lowercase_ : Dict=True , lowercase_ : int=True , lowercase_ : List[Any]=99 , lowercase_ : Optional[int]=32 , lowercase_ : int=2 , lowercase_ : int=4 , lowercase_ : Any=37 , lowercase_ : Union[str, Any]="gelu" , lowercase_ : int=0.1 , lowercase_ : Any=0.1 , lowercase_ : Optional[Any]=512 , lowercase_ : Optional[Any]=16 , lowercase_ : int=2 , lowercase_ : Optional[Any]=0.02 , lowercase_ : Union[str, Any]=False , lowercase_ : Optional[Any]=True , lowercase_ : int="None" , lowercase_ : Dict=3 , lowercase_ : Tuple=4 , lowercase_ : Optional[int]=None , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = parent SCREAMING_SNAKE_CASE_ : int = batch_size SCREAMING_SNAKE_CASE_ : Dict = seq_length SCREAMING_SNAKE_CASE_ : Dict = is_training SCREAMING_SNAKE_CASE_ : List[str] = use_input_mask SCREAMING_SNAKE_CASE_ : str = use_token_type_ids SCREAMING_SNAKE_CASE_ : List[str] = use_labels SCREAMING_SNAKE_CASE_ : Dict = vocab_size SCREAMING_SNAKE_CASE_ : Tuple = hidden_size SCREAMING_SNAKE_CASE_ : Dict = num_hidden_layers SCREAMING_SNAKE_CASE_ : Optional[Any] = num_attention_heads SCREAMING_SNAKE_CASE_ : Any = intermediate_size SCREAMING_SNAKE_CASE_ : Any = hidden_act SCREAMING_SNAKE_CASE_ : str = hidden_dropout_prob SCREAMING_SNAKE_CASE_ : Tuple = attention_probs_dropout_prob SCREAMING_SNAKE_CASE_ : List[Any] = max_position_embeddings SCREAMING_SNAKE_CASE_ : Dict = type_vocab_size SCREAMING_SNAKE_CASE_ : Optional[Any] = type_sequence_label_size SCREAMING_SNAKE_CASE_ : Union[str, Any] = initializer_range SCREAMING_SNAKE_CASE_ : str = num_labels SCREAMING_SNAKE_CASE_ : Optional[int] = num_choices SCREAMING_SNAKE_CASE_ : Dict = relative_attention SCREAMING_SNAKE_CASE_ : Union[str, Any] = position_biased_input SCREAMING_SNAKE_CASE_ : Union[str, Any] = pos_att_type SCREAMING_SNAKE_CASE_ : Union[str, Any] = scope def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[str] = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size) SCREAMING_SNAKE_CASE_ : Dict = None if self.use_input_mask: SCREAMING_SNAKE_CASE_ : Union[str, Any] = random_attention_mask([self.batch_size, self.seq_length]) SCREAMING_SNAKE_CASE_ : str = None if self.use_token_type_ids: SCREAMING_SNAKE_CASE_ : Optional[int] = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size) SCREAMING_SNAKE_CASE_ : Dict = None SCREAMING_SNAKE_CASE_ : Dict = None SCREAMING_SNAKE_CASE_ : List[Any] = None if self.use_labels: SCREAMING_SNAKE_CASE_ : Dict = ids_tensor([self.batch_size] , self.type_sequence_label_size) SCREAMING_SNAKE_CASE_ : int = ids_tensor([self.batch_size, self.seq_length] , self.num_labels) SCREAMING_SNAKE_CASE_ : Optional[Any] = 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=a__ , ) return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def _SCREAMING_SNAKE_CASE ( self : Optional[Any] , lowercase_ : Optional[int] , lowercase_ : Union[str, Any] , lowercase_ : int , lowercase_ : List[str] , lowercase_ : Union[str, Any] , lowercase_ : List[Any] , lowercase_ : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = TFDebertaVaModel(config=a__) SCREAMING_SNAKE_CASE_ : Union[str, Any] = {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids} SCREAMING_SNAKE_CASE_ : Union[str, Any] = [input_ids, input_mask] SCREAMING_SNAKE_CASE_ : Union[str, Any] = model(a__) SCREAMING_SNAKE_CASE_ : Tuple = model(a__) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size)) def _SCREAMING_SNAKE_CASE ( self : Dict , lowercase_ : Dict , lowercase_ : List[str] , lowercase_ : int , lowercase_ : List[str] , lowercase_ : List[Any] , lowercase_ : Union[str, Any] , lowercase_ : Any): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = TFDebertaVaForMaskedLM(config=a__) SCREAMING_SNAKE_CASE_ : List[str] = { '''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids, } SCREAMING_SNAKE_CASE_ : Dict = model(a__) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size)) def _SCREAMING_SNAKE_CASE ( self : int , lowercase_ : Optional[int] , lowercase_ : str , lowercase_ : Union[str, Any] , lowercase_ : Tuple , lowercase_ : Union[str, Any] , lowercase_ : Optional[Any] , lowercase_ : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = self.num_labels SCREAMING_SNAKE_CASE_ : Optional[int] = TFDebertaVaForSequenceClassification(config=a__) SCREAMING_SNAKE_CASE_ : Any = { '''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids, } SCREAMING_SNAKE_CASE_ : Dict = model(a__) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels)) def _SCREAMING_SNAKE_CASE ( self : Optional[int] , lowercase_ : List[Any] , lowercase_ : List[str] , lowercase_ : List[str] , lowercase_ : List[str] , lowercase_ : Optional[int] , lowercase_ : Optional[Any] , lowercase_ : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = self.num_labels SCREAMING_SNAKE_CASE_ : Dict = TFDebertaVaForTokenClassification(config=a__) SCREAMING_SNAKE_CASE_ : Union[str, Any] = { '''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids, } SCREAMING_SNAKE_CASE_ : Optional[Any] = model(a__) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels)) def _SCREAMING_SNAKE_CASE ( self : int , lowercase_ : int , lowercase_ : Dict , lowercase_ : Optional[int] , lowercase_ : Any , lowercase_ : int , lowercase_ : Optional[Any] , lowercase_ : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = TFDebertaVaForQuestionAnswering(config=a__) SCREAMING_SNAKE_CASE_ : int = { '''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids, } SCREAMING_SNAKE_CASE_ : Any = model(a__) 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 _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.prepare_config_and_inputs() ( ( SCREAMING_SNAKE_CASE_ ) , ( SCREAMING_SNAKE_CASE_ ) , ( SCREAMING_SNAKE_CASE_ ) , ( SCREAMING_SNAKE_CASE_ ) , ( SCREAMING_SNAKE_CASE_ ) , ( SCREAMING_SNAKE_CASE_ ) , ( SCREAMING_SNAKE_CASE_ ) , ) : Union[str, Any] = config_and_inputs SCREAMING_SNAKE_CASE_ : Union[str, Any] = {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask} return config, inputs_dict @require_tf class lowerCAmelCase__ ( lowerCAmelCase__ , lowerCAmelCase__ , unittest.TestCase ): '''simple docstring''' __UpperCamelCase = ( ( TFDebertaVaModel, TFDebertaVaForMaskedLM, TFDebertaVaForQuestionAnswering, TFDebertaVaForSequenceClassification, TFDebertaVaForTokenClassification, ) if is_tf_available() else () ) __UpperCamelCase = ( { "feature-extraction": TFDebertaVaModel, "fill-mask": TFDebertaVaForMaskedLM, "question-answering": TFDebertaVaForQuestionAnswering, "text-classification": TFDebertaVaForSequenceClassification, "token-classification": TFDebertaVaForTokenClassification, "zero-shot": TFDebertaVaForSequenceClassification, } if is_tf_available() else {} ) __UpperCamelCase = False __UpperCamelCase = False def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = TFDebertaVaModelTester(self) SCREAMING_SNAKE_CASE_ : Any = ConfigTester(self , config_class=a__ , hidden_size=37) def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' self.config_tester.run_common_tests() def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*a__) def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*a__) def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_question_answering(*a__) def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_sequence_classification(*a__) def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*a__) @slow def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = TFDebertaVaModel.from_pretrained('''kamalkraj/deberta-v2-xlarge''') self.assertIsNotNone(a__) @require_tf class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' @unittest.skip(reason='''Model not available yet''') def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' pass @slow def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = TFDebertaVaModel.from_pretrained('''kamalkraj/deberta-v2-xlarge''') SCREAMING_SNAKE_CASE_ : Optional[int] = tf.constant([[0, 31414, 232, 328, 740, 1140, 12695, 69, 46078, 1588, 2]]) SCREAMING_SNAKE_CASE_ : List[Any] = tf.constant([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]) SCREAMING_SNAKE_CASE_ : str = model(a__ , attention_mask=a__)[0] SCREAMING_SNAKE_CASE_ : Tuple = tf.constant( [[[0.23_56, 0.19_48, 0.03_69], [-0.10_63, 0.35_86, -0.51_52], [-0.63_99, -0.02_59, -0.25_25]]]) tf.debugging.assert_near(output[:, 1:4, 1:4] , a__ , atol=1e-4)
364
"""simple docstring""" from __future__ import annotations UpperCAmelCase_ : List[str] = list[list[int]] # assigning initial values to the grid UpperCAmelCase_ : Matrix = [ [3, 0, 6, 5, 0, 8, 4, 0, 0], [5, 2, 0, 0, 0, 0, 0, 0, 0], [0, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] # a grid with no solution UpperCAmelCase_ : Matrix = [ [5, 0, 6, 5, 0, 8, 4, 0, 3], [5, 2, 0, 0, 0, 0, 0, 0, 2], [1, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] def _A (__a , __a , __a , __a ) -> bool: """simple docstring""" for i in range(9 ): if grid[row][i] == n or grid[i][column] == n: return False for i in range(3 ): for j in range(3 ): if grid[(row - row % 3) + i][(column - column % 3) + j] == n: return False return True def _A (__a ) -> tuple[int, int] | None: """simple docstring""" for i in range(9 ): for j in range(9 ): if grid[i][j] == 0: return i, j return None def _A (__a ) -> Matrix | None: """simple docstring""" if location := find_empty_location(__a ): SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Dict = location else: # If the location is ``None``, then the grid is solved. return grid for digit in range(1 , 10 ): if is_safe(__a , __a , __a , __a ): SCREAMING_SNAKE_CASE_ : Tuple = digit if sudoku(__a ) is not None: return grid SCREAMING_SNAKE_CASE_ : Any = 0 return None def _A (__a ) -> None: """simple docstring""" for row in grid: for cell in row: print(__a , end=''' ''' ) print() if __name__ == "__main__": # make a copy of grid so that you can compare with the unmodified grid for example_grid in (initial_grid, no_solution): print("""\nExample grid:\n""" + """=""" * 20) print_solution(example_grid) print("""\nExample grid solution:""") UpperCAmelCase_ : str = sudoku(example_grid) if solution is not None: print_solution(solution) else: print("""Cannot find a solution.""")
318
0
"""simple docstring""" def _A (__a ) -> list: """simple docstring""" if n_term == "": return [] SCREAMING_SNAKE_CASE_ : Tuple = [] for temp in range(int(snake_case__ ) ): series.append(f'1/{temp + 1}' if series else '''1''' ) return series if __name__ == "__main__": UpperCAmelCase_ : int = input("""Enter the last number (nth term) of the Harmonic Series""") print("""Formula of Harmonic Series => 1+1/2+1/3 ..... 1/n""") print(harmonic_series(nth_term))
365
"""simple docstring""" from itertools import permutations def _A (__a ) -> bool: """simple docstring""" if num[3] % 2 != 0: return False if (num[2] + num[3] + num[4]) % 3 != 0: return False if num[5] % 5 != 0: return False SCREAMING_SNAKE_CASE_ : List[str] = [7, 11, 13, 17] for i, test in enumerate(__a ): if (num[i + 4] * 1_00 + num[i + 5] * 10 + num[i + 6]) % test != 0: return False return True def _A (__a = 10 ) -> int: """simple docstring""" return sum( int(''''''.join(map(__a , __a ) ) ) for num in permutations(range(__a ) ) if is_substring_divisible(__a ) ) if __name__ == "__main__": print(f'''{solution() = }''')
318
0
"""simple docstring""" from __future__ import annotations import unittest from transformers import AutoTokenizer, PegasusConfig, is_tf_available from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow from transformers.utils import cached_property from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import tensorflow as tf from transformers import TFAutoModelForSeqaSeqLM, TFPegasusForConditionalGeneration, TFPegasusModel @require_tf class lowerCAmelCase__ : '''simple docstring''' __UpperCamelCase = PegasusConfig __UpperCamelCase = {} __UpperCamelCase = "gelu" def __init__( self : Optional[int] , lowercase_ : Tuple , lowercase_ : Optional[Any]=13 , lowercase_ : Optional[int]=7 , lowercase_ : Optional[int]=True , lowercase_ : Any=False , lowercase_ : Tuple=99 , lowercase_ : int=32 , lowercase_ : Optional[Any]=2 , lowercase_ : int=4 , lowercase_ : int=37 , lowercase_ : Union[str, Any]=0.1 , lowercase_ : str=0.1 , lowercase_ : List[Any]=40 , lowercase_ : Optional[int]=2 , lowercase_ : List[Any]=1 , lowercase_ : Dict=0 , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = parent SCREAMING_SNAKE_CASE_ : Dict = batch_size SCREAMING_SNAKE_CASE_ : List[Any] = seq_length SCREAMING_SNAKE_CASE_ : Optional[Any] = is_training SCREAMING_SNAKE_CASE_ : List[Any] = use_labels SCREAMING_SNAKE_CASE_ : Any = vocab_size SCREAMING_SNAKE_CASE_ : List[str] = hidden_size SCREAMING_SNAKE_CASE_ : Optional[Any] = num_hidden_layers SCREAMING_SNAKE_CASE_ : List[Any] = num_attention_heads SCREAMING_SNAKE_CASE_ : int = intermediate_size SCREAMING_SNAKE_CASE_ : Optional[int] = hidden_dropout_prob SCREAMING_SNAKE_CASE_ : List[Any] = attention_probs_dropout_prob SCREAMING_SNAKE_CASE_ : Tuple = max_position_embeddings SCREAMING_SNAKE_CASE_ : Optional[Any] = eos_token_id SCREAMING_SNAKE_CASE_ : int = pad_token_id SCREAMING_SNAKE_CASE_ : List[str] = bos_token_id def _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = ids_tensor([self.batch_size, self.seq_length - 1] , self.vocab_size) SCREAMING_SNAKE_CASE_ : Optional[int] = tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size) , 1) SCREAMING_SNAKE_CASE_ : Union[str, Any] = tf.concat([input_ids, eos_tensor] , axis=1) SCREAMING_SNAKE_CASE_ : Optional[Any] = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size) SCREAMING_SNAKE_CASE_ : Union[str, Any] = 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 , ) SCREAMING_SNAKE_CASE_ : List[str] = prepare_pegasus_inputs_dict(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_) return config, inputs_dict def _SCREAMING_SNAKE_CASE ( self : Any , lowercase_ : Tuple , lowercase_ : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[str] = TFPegasusModel(config=SCREAMING_SNAKE_CASE_).get_decoder() SCREAMING_SNAKE_CASE_ : List[Any] = inputs_dict["""input_ids"""] SCREAMING_SNAKE_CASE_ : Union[str, Any] = input_ids[:1, :] SCREAMING_SNAKE_CASE_ : int = inputs_dict["""attention_mask"""][:1, :] SCREAMING_SNAKE_CASE_ : List[Any] = inputs_dict["""head_mask"""] SCREAMING_SNAKE_CASE_ : Dict = 1 # first forward pass SCREAMING_SNAKE_CASE_ : Any = model(SCREAMING_SNAKE_CASE_ , attention_mask=SCREAMING_SNAKE_CASE_ , head_mask=SCREAMING_SNAKE_CASE_ , use_cache=SCREAMING_SNAKE_CASE_) SCREAMING_SNAKE_CASE_ : Tuple = outputs.to_tuple() # create hypothetical next token and extent to next_input_ids SCREAMING_SNAKE_CASE_ : Union[str, Any] = ids_tensor((self.batch_size, 3) , config.vocab_size) SCREAMING_SNAKE_CASE_ : List[Any] = tf.cast(ids_tensor((self.batch_size, 3) , 2) , tf.inta) # append to next input_ids and SCREAMING_SNAKE_CASE_ : Dict = tf.concat([input_ids, next_tokens] , axis=-1) SCREAMING_SNAKE_CASE_ : Any = tf.concat([attention_mask, next_attn_mask] , axis=-1) SCREAMING_SNAKE_CASE_ : str = model(SCREAMING_SNAKE_CASE_ , attention_mask=SCREAMING_SNAKE_CASE_)[0] SCREAMING_SNAKE_CASE_ : Optional[Any] = model(SCREAMING_SNAKE_CASE_ , attention_mask=SCREAMING_SNAKE_CASE_ , past_key_values=SCREAMING_SNAKE_CASE_)[0] self.parent.assertEqual(next_tokens.shape[1] , output_from_past.shape[1]) # select random slice SCREAMING_SNAKE_CASE_ : List[Any] = int(ids_tensor((1,) , output_from_past.shape[-1])) SCREAMING_SNAKE_CASE_ : Tuple = output_from_no_past[:, -3:, random_slice_idx] SCREAMING_SNAKE_CASE_ : List[Any] = output_from_past[:, :, random_slice_idx] # test that outputs are equal for slice tf.debugging.assert_near(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , rtol=1e-3) def _A (__a , __a , __a , __a=None , __a=None , __a=None , __a=None , __a=None , ): """simple docstring""" if attention_mask is None: SCREAMING_SNAKE_CASE_ : Dict = tf.cast(tf.math.not_equal(lowerCAmelCase__ , config.pad_token_id ) , tf.inta ) if decoder_attention_mask is None: SCREAMING_SNAKE_CASE_ : Any = tf.concat( [ tf.ones(decoder_input_ids[:, :1].shape , dtype=tf.inta ), tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:] , config.pad_token_id ) , tf.inta ), ] , axis=-1 , ) if head_mask is None: SCREAMING_SNAKE_CASE_ : Union[str, Any] = tf.ones((config.encoder_layers, config.encoder_attention_heads) ) if decoder_head_mask is None: SCREAMING_SNAKE_CASE_ : Union[str, Any] = tf.ones((config.decoder_layers, config.decoder_attention_heads) ) if cross_attn_head_mask is None: SCREAMING_SNAKE_CASE_ : Tuple = tf.ones((config.decoder_layers, config.decoder_attention_heads) ) return { "input_ids": input_ids, "decoder_input_ids": decoder_input_ids, "attention_mask": attention_mask, "decoder_attention_mask": decoder_attention_mask, "head_mask": head_mask, "decoder_head_mask": decoder_head_mask, "cross_attn_head_mask": cross_attn_head_mask, } @require_tf class lowerCAmelCase__ ( _lowerCAmelCase , _lowerCAmelCase , unittest.TestCase ): '''simple docstring''' __UpperCamelCase = (TFPegasusForConditionalGeneration, TFPegasusModel) if is_tf_available() else () __UpperCamelCase = (TFPegasusForConditionalGeneration,) if is_tf_available() else () __UpperCamelCase = ( { "conversational": TFPegasusForConditionalGeneration, "feature-extraction": TFPegasusModel, "summarization": TFPegasusForConditionalGeneration, "text2text-generation": TFPegasusForConditionalGeneration, "translation": TFPegasusForConditionalGeneration, } if is_tf_available() else {} ) __UpperCamelCase = True __UpperCamelCase = False __UpperCamelCase = False def _SCREAMING_SNAKE_CASE ( self : Tuple): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = TFPegasusModelTester(self) SCREAMING_SNAKE_CASE_ : Optional[Any] = ConfigTester(self , config_class=SCREAMING_SNAKE_CASE_) def _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' self.config_tester.run_common_tests() def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.check_decoder_model_past_large_inputs(*SCREAMING_SNAKE_CASE_) @require_sentencepiece @require_tokenizers @require_tf class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' __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 cut power to hundreds of thousands of customers in an effort to" " reduce the risk of wildfires.", "N-Dubz have revealed they\'re \"grateful\" to have been nominated for four Mobo Awards.", ] # differs slightly from pytorch, likely due to numerical differences in linear layers __UpperCamelCase = "google/pegasus-xsum" @cached_property def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' return AutoTokenizer.from_pretrained(self.model_name) @cached_property def _SCREAMING_SNAKE_CASE ( self : Any): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name) return model def _SCREAMING_SNAKE_CASE ( self : Union[str, Any] , **lowercase_ : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = self.translate_src_text(**SCREAMING_SNAKE_CASE_) assert self.expected_text == generated_words def _SCREAMING_SNAKE_CASE ( self : int , **lowercase_ : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = self.tokenizer(self.src_text , **SCREAMING_SNAKE_CASE_ , padding=SCREAMING_SNAKE_CASE_ , return_tensors='''tf''') SCREAMING_SNAKE_CASE_ : Optional[Any] = self.model.generate( model_inputs.input_ids , attention_mask=model_inputs.attention_mask , num_beams=2 , use_cache=SCREAMING_SNAKE_CASE_ , ) SCREAMING_SNAKE_CASE_ : Any = self.tokenizer.batch_decode(generated_ids.numpy() , skip_special_tokens=SCREAMING_SNAKE_CASE_) return generated_words @slow def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' self._assert_generated_batch_equal_expected()
366
"""simple docstring""" UpperCAmelCase_ : List[Any] = 9.8_0_6_6_5 def _A (__a , __a , __a = g ) -> float: """simple docstring""" if fluid_density <= 0: raise ValueError('''Impossible fluid density''' ) if volume < 0: raise ValueError('''Impossible Object volume''' ) if gravity <= 0: raise ValueError('''Impossible Gravity''' ) return fluid_density * gravity * volume if __name__ == "__main__": import doctest # run doctest doctest.testmod()
318
0
"""simple docstring""" from manim import * class lowerCAmelCase__ ( __SCREAMING_SNAKE_CASE ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = Rectangle(height=0.5 , width=0.5) SCREAMING_SNAKE_CASE_ : Union[str, Any] = Rectangle(height=0.46 , width=0.46).set_stroke(width=0) SCREAMING_SNAKE_CASE_ : Optional[int] = [mem.copy() for i in range(6)] SCREAMING_SNAKE_CASE_ : List[Any] = [mem.copy() for i in range(6)] SCREAMING_SNAKE_CASE_ : Optional[Any] = VGroup(*UpperCamelCase__).arrange(UpperCamelCase__ , buff=0) SCREAMING_SNAKE_CASE_ : List[Any] = VGroup(*UpperCamelCase__).arrange(UpperCamelCase__ , buff=0) SCREAMING_SNAKE_CASE_ : int = VGroup(UpperCamelCase__ , UpperCamelCase__).arrange(UpperCamelCase__ , buff=0) SCREAMING_SNAKE_CASE_ : List[str] = Text('''CPU''' , font_size=24) SCREAMING_SNAKE_CASE_ : Tuple = Group(UpperCamelCase__ , UpperCamelCase__).arrange(UpperCamelCase__ , buff=0.5 , aligned_edge=UpperCamelCase__) cpu.move_to([-2.5, -0.5, 0]) self.add(UpperCamelCase__) SCREAMING_SNAKE_CASE_ : Union[str, Any] = [mem.copy() for i in range(1)] SCREAMING_SNAKE_CASE_ : Any = VGroup(*UpperCamelCase__).arrange(UpperCamelCase__ , buff=0) SCREAMING_SNAKE_CASE_ : Any = Text('''GPU''' , font_size=24) SCREAMING_SNAKE_CASE_ : str = Group(UpperCamelCase__ , UpperCamelCase__).arrange(UpperCamelCase__ , buff=0.5 , aligned_edge=UpperCamelCase__) gpu.align_to(UpperCamelCase__ , UpperCamelCase__) gpu.set_x(gpu.get_x() - 1) self.add(UpperCamelCase__) SCREAMING_SNAKE_CASE_ : Optional[Any] = [mem.copy() for i in range(6)] SCREAMING_SNAKE_CASE_ : Union[str, Any] = VGroup(*UpperCamelCase__).arrange(UpperCamelCase__ , buff=0) SCREAMING_SNAKE_CASE_ : Optional[Any] = Text('''Model''' , font_size=24) SCREAMING_SNAKE_CASE_ : Optional[int] = Group(UpperCamelCase__ , UpperCamelCase__).arrange(UpperCamelCase__ , buff=0.5 , aligned_edge=UpperCamelCase__) model.move_to([3, -1.0, 0]) self.play( Create(UpperCamelCase__ , run_time=1) , Create(UpperCamelCase__ , run_time=1) , Create(UpperCamelCase__ , run_time=1) , ) SCREAMING_SNAKE_CASE_ : List[str] = MarkupText( F'First, an empty model skeleton is loaded\ninto <span fgcolor=\'{YELLOW}\'>memory</span> without using much RAM.' , font_size=24 , ) SCREAMING_SNAKE_CASE_ : Any = Square(side_length=2.2) key.move_to([-5, 2, 0]) SCREAMING_SNAKE_CASE_ : Dict = MarkupText( F'<b>Key:</b>\n\n<span fgcolor=\'{YELLOW}\'>●</span> Empty Model' , font_size=18 , ) key_text.move_to([-5, 2.4, 0]) step_a.move_to([2, 2, 0]) self.play(Write(UpperCamelCase__ , run_time=2.5) , Write(UpperCamelCase__) , Write(UpperCamelCase__)) self.add(UpperCamelCase__) SCREAMING_SNAKE_CASE_ : Union[str, Any] = [] SCREAMING_SNAKE_CASE_ : str = [] SCREAMING_SNAKE_CASE_ : int = [] for i, rect in enumerate(UpperCamelCase__): SCREAMING_SNAKE_CASE_ : str = Rectangle(height=0.46 , width=0.46).set_stroke(width=0.0).set_fill(UpperCamelCase__ , opacity=0.7) cpu_target.move_to(UpperCamelCase__) cpu_target.generate_target() SCREAMING_SNAKE_CASE_ : Optional[int] = 0.46 / 4 SCREAMING_SNAKE_CASE_ : int = 0.46 / 3 if i == 0: cpu_target.target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT) , buff=0.02 , direction=UpperCamelCase__) cpu_target.target.set_x(cpu_target.target.get_x() + 0.1) elif i == 3: cpu_target.target.next_to(cpu_targs[0].target , direction=UpperCamelCase__ , buff=0.0) else: cpu_target.target.next_to(cpu_targs[i - 1].target , direction=UpperCamelCase__ , buff=0.0) cpu_targs.append(UpperCamelCase__) first_animations.append(rect.animate(run_time=0.5).set_stroke(UpperCamelCase__)) second_animations.append(MoveToTarget(UpperCamelCase__ , run_time=1.5)) self.play(*UpperCamelCase__) self.play(*UpperCamelCase__) self.wait()
367
"""simple docstring""" # tests directory-specific settings - this file is run automatically # by pytest before any tests are run import sys import warnings from os.path import abspath, dirname, join # allow having multiple repository checkouts and not needing to remember to rerun # 'pip install -e .[dev]' when switching between checkouts and running tests. UpperCAmelCase_ : Union[str, Any] = abspath(join(dirname(dirname(dirname(__file__))), """src""")) sys.path.insert(1, git_repo_path) # silence FutureWarning warnings in tests since often we can't act on them until # they become normal warnings - i.e. the tests still need to test the current functionality warnings.simplefilter(action="""ignore""", category=FutureWarning) def _A (__a ) -> Union[str, Any]: """simple docstring""" from transformers.testing_utils import pytest_addoption_shared pytest_addoption_shared(__a ) def _A (__a ) -> Any: """simple docstring""" from transformers.testing_utils import pytest_terminal_summary_main SCREAMING_SNAKE_CASE_ : Optional[Any] = terminalreporter.config.getoption('''--make-reports''' ) if make_reports: pytest_terminal_summary_main(__a , id=__a )
318
0
"""simple docstring""" from __future__ import annotations def _A (__a , __a , __a ) -> int | float: """simple docstring""" if len(lowerCamelCase_ ) == 0: raise ValueError('''find_max() arg is an empty sequence''' ) if ( left >= len(lowerCamelCase_ ) or left < -len(lowerCamelCase_ ) or right >= len(lowerCamelCase_ ) or right < -len(lowerCamelCase_ ) ): raise IndexError('''list index out of range''' ) if left == right: return nums[left] SCREAMING_SNAKE_CASE_ : str = (left + right) >> 1 # the middle SCREAMING_SNAKE_CASE_ : int = find_max(lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) # find max in range[left, mid] SCREAMING_SNAKE_CASE_ : Dict = find_max(lowerCamelCase_ , mid + 1 , lowerCamelCase_ ) # find max in range[mid + 1, right] return left_max if left_max >= right_max else right_max if __name__ == "__main__": import doctest doctest.testmod(verbose=True)
368
"""simple docstring""" import argparse import os import re import packaging.version UpperCAmelCase_ : Any = """examples/""" UpperCAmelCase_ : Optional[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"""), } UpperCAmelCase_ : List[Any] = { """init""": """src/transformers/__init__.py""", """setup""": """setup.py""", } UpperCAmelCase_ : Optional[int] = """README.md""" def _A (__a , __a , __a ) -> int: """simple docstring""" with open(__a , '''r''' , encoding='''utf-8''' , newline='''\n''' ) as f: SCREAMING_SNAKE_CASE_ : Optional[Any] = f.read() SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : List[Any] = REPLACE_PATTERNS[pattern] SCREAMING_SNAKE_CASE_ : Optional[int] = replace.replace('''VERSION''' , __a ) SCREAMING_SNAKE_CASE_ : Tuple = re_pattern.sub(__a , __a ) with open(__a , '''w''' , encoding='''utf-8''' , newline='''\n''' ) as f: f.write(__a ) def _A (__a ) -> int: """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 _A (__a , __a=False ) -> List[str]: """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 _A () -> int: """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[Any] = '''🤗 Transformers currently provides the following architectures''' SCREAMING_SNAKE_CASE_ : Optional[int] = '''1. Want to contribute a new model?''' with open(__a , '''r''' , encoding='''utf-8''' , newline='''\n''' ) as f: SCREAMING_SNAKE_CASE_ : Tuple = f.readlines() # Find the start of the list. SCREAMING_SNAKE_CASE_ : Tuple = 0 while not lines[start_index].startswith(_start_prompt ): start_index += 1 start_index += 1 SCREAMING_SNAKE_CASE_ : Dict = start_index # Update the lines in the model list. while not lines[index].startswith(_end_prompt ): if lines[index].startswith('''1.''' ): SCREAMING_SNAKE_CASE_ : List[Any] = 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 _A () -> List[str]: """simple docstring""" with open(REPLACE_FILES['''init'''] , '''r''' ) as f: SCREAMING_SNAKE_CASE_ : Any = f.read() SCREAMING_SNAKE_CASE_ : Dict = REPLACE_PATTERNS['''init'''][0].search(__a ).groups()[0] return packaging.version.parse(__a ) def _A (__a=False ) -> List[Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Tuple = 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: SCREAMING_SNAKE_CASE_ : List[Any] = default_version.base_version elif patch: SCREAMING_SNAKE_CASE_ : int = f'{default_version.major}.{default_version.minor}.{default_version.micro + 1}' else: SCREAMING_SNAKE_CASE_ : Any = f'{default_version.major}.{default_version.minor + 1}.0' # Now let's ask nicely if that's the right one. SCREAMING_SNAKE_CASE_ : int = input(f'Which version are you releasing? [{default_version}]' ) if len(__a ) == 0: SCREAMING_SNAKE_CASE_ : Optional[Any] = 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 _A () -> Any: """simple docstring""" SCREAMING_SNAKE_CASE_ : Any = get_version() SCREAMING_SNAKE_CASE_ : Any = f'{current_version.major}.{current_version.minor + 1}.0.dev0' SCREAMING_SNAKE_CASE_ : Union[str, Any] = current_version.base_version # Check with the user we got that right. SCREAMING_SNAKE_CASE_ : int = input(f'Which version are we developing now? [{dev_version}]' ) if len(__a ) == 0: SCREAMING_SNAKE_CASE_ : Optional[int] = 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__": UpperCAmelCase_ : Optional[int] = argparse.ArgumentParser() parser.add_argument("""--post_release""", action="""store_true""", help="""Whether this is pre or post release.""") parser.add_argument("""--patch""", action="""store_true""", help="""Whether or not this is a patch release.""") UpperCAmelCase_ : 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()
318
0
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available UpperCAmelCase_ : Optional[Any] = { """configuration_conditional_detr""": [ """CONDITIONAL_DETR_PRETRAINED_CONFIG_ARCHIVE_MAP""", """ConditionalDetrConfig""", """ConditionalDetrOnnxConfig""", ] } try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase_ : int = ["""ConditionalDetrFeatureExtractor"""] UpperCAmelCase_ : Optional[Any] = ["""ConditionalDetrImageProcessor"""] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase_ : int = [ """CONDITIONAL_DETR_PRETRAINED_MODEL_ARCHIVE_LIST""", """ConditionalDetrForObjectDetection""", """ConditionalDetrForSegmentation""", """ConditionalDetrModel""", """ConditionalDetrPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_conditional_detr import ( CONDITIONAL_DETR_PRETRAINED_CONFIG_ARCHIVE_MAP, ConditionalDetrConfig, ConditionalDetrOnnxConfig, ) try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_conditional_detr import ConditionalDetrFeatureExtractor from .image_processing_conditional_detr import ConditionalDetrImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_conditional_detr import ( CONDITIONAL_DETR_PRETRAINED_MODEL_ARCHIVE_LIST, ConditionalDetrForObjectDetection, ConditionalDetrForSegmentation, ConditionalDetrModel, ConditionalDetrPreTrainedModel, ) else: import sys UpperCAmelCase_ : Any = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
369
"""simple docstring""" from typing import Optional, Tuple import jax import jax.numpy as jnp from flax import linen as nn from flax.core.frozen_dict import FrozenDict from transformers import CLIPConfig, FlaxPreTrainedModel from transformers.models.clip.modeling_flax_clip import FlaxCLIPVisionModule def _A (__a , __a , __a=1e-12 ) -> List[Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Union[str, Any] = jnp.divide(emb_a.T , jnp.clip(jnp.linalg.norm(__a , axis=1 ) , a_min=__a ) ).T SCREAMING_SNAKE_CASE_ : List[Any] = jnp.divide(emb_a.T , jnp.clip(jnp.linalg.norm(__a , axis=1 ) , a_min=__a ) ).T return jnp.matmul(__a , norm_emb_a.T ) class lowerCAmelCase__ ( nn.Module ): '''simple docstring''' __UpperCamelCase = 42 __UpperCamelCase = jnp.floataa def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = FlaxCLIPVisionModule(self.config.vision_config) SCREAMING_SNAKE_CASE_ : Tuple = nn.Dense(self.config.projection_dim , use_bias=lowercase_ , dtype=self.dtype) SCREAMING_SNAKE_CASE_ : List[str] = self.param('''concept_embeds''' , jax.nn.initializers.ones , (17, self.config.projection_dim)) SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.param( '''special_care_embeds''' , jax.nn.initializers.ones , (3, self.config.projection_dim)) SCREAMING_SNAKE_CASE_ : Dict = self.param('''concept_embeds_weights''' , jax.nn.initializers.ones , (17,)) SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.param('''special_care_embeds_weights''' , jax.nn.initializers.ones , (3,)) def __call__( self : Optional[Any] , lowercase_ : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = self.vision_model(lowercase_)[1] SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.visual_projection(lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = jax_cosine_distance(lowercase_ , self.special_care_embeds) SCREAMING_SNAKE_CASE_ : List[str] = jax_cosine_distance(lowercase_ , self.concept_embeds) # increase this value to create a stronger `nfsw` filter # at the cost of increasing the possibility of filtering benign image inputs SCREAMING_SNAKE_CASE_ : Tuple = 0.0 SCREAMING_SNAKE_CASE_ : Dict = special_cos_dist - self.special_care_embeds_weights[None, :] + adjustment SCREAMING_SNAKE_CASE_ : Optional[int] = jnp.round(lowercase_ , 3) SCREAMING_SNAKE_CASE_ : List[Any] = jnp.any(special_scores > 0 , axis=1 , keepdims=lowercase_) # Use a lower threshold if an image has any special care concept SCREAMING_SNAKE_CASE_ : Dict = is_special_care * 0.01 SCREAMING_SNAKE_CASE_ : str = cos_dist - self.concept_embeds_weights[None, :] + special_adjustment SCREAMING_SNAKE_CASE_ : Any = jnp.round(lowercase_ , 3) SCREAMING_SNAKE_CASE_ : Dict = jnp.any(concept_scores > 0 , axis=1) return has_nsfw_concepts class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = CLIPConfig __UpperCamelCase = "clip_input" __UpperCamelCase = FlaxStableDiffusionSafetyCheckerModule def __init__( self : Union[str, Any] , lowercase_ : CLIPConfig , lowercase_ : Optional[Tuple] = None , lowercase_ : int = 0 , lowercase_ : jnp.dtype = jnp.floataa , lowercase_ : bool = True , **lowercase_ : Any , ): '''simple docstring''' if input_shape is None: SCREAMING_SNAKE_CASE_ : List[str] = (1, 224, 224, 3) SCREAMING_SNAKE_CASE_ : List[Any] = self.module_class(config=lowercase_ , dtype=lowercase_ , **lowercase_) super().__init__(lowercase_ , lowercase_ , input_shape=lowercase_ , seed=lowercase_ , dtype=lowercase_ , _do_init=_do_init) def _SCREAMING_SNAKE_CASE ( self : Tuple , lowercase_ : jax.random.KeyArray , lowercase_ : Tuple , lowercase_ : FrozenDict = None): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = jax.random.normal(lowercase_ , lowercase_) SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Union[str, Any] = jax.random.split(lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = {'''params''': params_rng, '''dropout''': dropout_rng} SCREAMING_SNAKE_CASE_ : List[Any] = self.module.init(lowercase_ , lowercase_)['''params'''] return random_params def __call__( self : List[Any] , lowercase_ : List[str] , lowercase_ : dict = None , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = jnp.transpose(lowercase_ , (0, 2, 3, 1)) return self.module.apply( {'''params''': params or self.params} , jnp.array(lowercase_ , dtype=jnp.floataa) , rngs={} , )
318
0
import argparse import json from collections import OrderedDict from pathlib import Path import requests import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import ( SegformerConfig, SegformerForImageClassification, SegformerForSemanticSegmentation, SegformerImageProcessor, ) from transformers.utils import logging logging.set_verbosity_info() UpperCAmelCase_ : Tuple = logging.get_logger(__name__) def _A (__a , __a=False ) -> Dict: """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[Any] = OrderedDict() for key, value in state_dict.items(): if encoder_only and not key.startswith('''head''' ): SCREAMING_SNAKE_CASE_ : Union[str, Any] = '''segformer.encoder.''' + key if key.startswith('''backbone''' ): SCREAMING_SNAKE_CASE_ : Tuple = key.replace('''backbone''' , '''segformer.encoder''' ) if "patch_embed" in key: # replace for example patch_embed1 by patch_embeddings.0 SCREAMING_SNAKE_CASE_ : str = key[key.find('''patch_embed''' ) + len('''patch_embed''' )] SCREAMING_SNAKE_CASE_ : str = key.replace(f'patch_embed{idx}' , f'patch_embeddings.{int(snake_case_ )-1}' ) if "norm" in key: SCREAMING_SNAKE_CASE_ : str = key.replace('''norm''' , '''layer_norm''' ) if "segformer.encoder.layer_norm" in key: # replace for example layer_norm1 by layer_norm.0 SCREAMING_SNAKE_CASE_ : int = key[key.find('''segformer.encoder.layer_norm''' ) + len('''segformer.encoder.layer_norm''' )] SCREAMING_SNAKE_CASE_ : List[Any] = key.replace(f'layer_norm{idx}' , f'layer_norm.{int(snake_case_ )-1}' ) if "layer_norm1" in key: SCREAMING_SNAKE_CASE_ : List[Any] = key.replace('''layer_norm1''' , '''layer_norm_1''' ) if "layer_norm2" in key: SCREAMING_SNAKE_CASE_ : Optional[int] = key.replace('''layer_norm2''' , '''layer_norm_2''' ) if "block" in key: # replace for example block1 by block.0 SCREAMING_SNAKE_CASE_ : Any = key[key.find('''block''' ) + len('''block''' )] SCREAMING_SNAKE_CASE_ : Optional[Any] = key.replace(f'block{idx}' , f'block.{int(snake_case_ )-1}' ) if "attn.q" in key: SCREAMING_SNAKE_CASE_ : Tuple = key.replace('''attn.q''' , '''attention.self.query''' ) if "attn.proj" in key: SCREAMING_SNAKE_CASE_ : List[Any] = key.replace('''attn.proj''' , '''attention.output.dense''' ) if "attn" in key: SCREAMING_SNAKE_CASE_ : Any = key.replace('''attn''' , '''attention.self''' ) if "fc1" in key: SCREAMING_SNAKE_CASE_ : Tuple = key.replace('''fc1''' , '''dense1''' ) if "fc2" in key: SCREAMING_SNAKE_CASE_ : Tuple = key.replace('''fc2''' , '''dense2''' ) if "linear_pred" in key: SCREAMING_SNAKE_CASE_ : Dict = key.replace('''linear_pred''' , '''classifier''' ) if "linear_fuse" in key: SCREAMING_SNAKE_CASE_ : List[str] = key.replace('''linear_fuse.conv''' , '''linear_fuse''' ) SCREAMING_SNAKE_CASE_ : str = key.replace('''linear_fuse.bn''' , '''batch_norm''' ) if "linear_c" in key: # replace for example linear_c4 by linear_c.3 SCREAMING_SNAKE_CASE_ : Dict = key[key.find('''linear_c''' ) + len('''linear_c''' )] SCREAMING_SNAKE_CASE_ : Dict = key.replace(f'linear_c{idx}' , f'linear_c.{int(snake_case_ )-1}' ) if key.startswith('''head''' ): SCREAMING_SNAKE_CASE_ : Union[str, Any] = key.replace('''head''' , '''classifier''' ) SCREAMING_SNAKE_CASE_ : Optional[int] = value return new_state_dict def _A (__a , __a ) -> Union[str, Any]: """simple docstring""" for i in range(config.num_encoder_blocks ): for j in range(config.depths[i] ): # read in weights + bias of keys and values (which is a single matrix in the original implementation) SCREAMING_SNAKE_CASE_ : List[str] = state_dict.pop(f'segformer.encoder.block.{i}.{j}.attention.self.kv.weight' ) SCREAMING_SNAKE_CASE_ : List[str] = state_dict.pop(f'segformer.encoder.block.{i}.{j}.attention.self.kv.bias' ) # next, add keys and values (in that order) to the state dict SCREAMING_SNAKE_CASE_ : List[Any] = kv_weight[ : config.hidden_sizes[i], : ] SCREAMING_SNAKE_CASE_ : Tuple = kv_bias[: config.hidden_sizes[i]] SCREAMING_SNAKE_CASE_ : Any = kv_weight[ config.hidden_sizes[i] :, : ] SCREAMING_SNAKE_CASE_ : Dict = kv_bias[ config.hidden_sizes[i] : ] def _A () -> List[Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : str = '''http://images.cocodataset.org/val2017/000000039769.jpg''' SCREAMING_SNAKE_CASE_ : Optional[int] = Image.open(requests.get(snake_case_ , stream=snake_case_ ).raw ) return image @torch.no_grad() def _A (__a , __a , __a ) -> Union[str, Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : str = SegformerConfig() SCREAMING_SNAKE_CASE_ : int = False # set attributes based on model_name SCREAMING_SNAKE_CASE_ : Tuple = '''huggingface/label-files''' if "segformer" in model_name: SCREAMING_SNAKE_CASE_ : Optional[Any] = model_name[len('''segformer.''' ) : len('''segformer.''' ) + 2] if "ade" in model_name: SCREAMING_SNAKE_CASE_ : int = 1_50 SCREAMING_SNAKE_CASE_ : List[str] = '''ade20k-id2label.json''' SCREAMING_SNAKE_CASE_ : Dict = (1, 1_50, 1_28, 1_28) elif "city" in model_name: SCREAMING_SNAKE_CASE_ : Tuple = 19 SCREAMING_SNAKE_CASE_ : str = '''cityscapes-id2label.json''' SCREAMING_SNAKE_CASE_ : Tuple = (1, 19, 1_28, 1_28) else: raise ValueError(f'Model {model_name} not supported' ) elif "mit" in model_name: SCREAMING_SNAKE_CASE_ : Tuple = True SCREAMING_SNAKE_CASE_ : List[Any] = model_name[4:6] SCREAMING_SNAKE_CASE_ : str = 10_00 SCREAMING_SNAKE_CASE_ : List[str] = '''imagenet-1k-id2label.json''' SCREAMING_SNAKE_CASE_ : Optional[int] = (1, 10_00) else: raise ValueError(f'Model {model_name} not supported' ) # set config attributes SCREAMING_SNAKE_CASE_ : int = json.load(open(hf_hub_download(snake_case_ , snake_case_ , repo_type='''dataset''' ) , '''r''' ) ) SCREAMING_SNAKE_CASE_ : Tuple = {int(snake_case_ ): v for k, v in idalabel.items()} SCREAMING_SNAKE_CASE_ : Union[str, Any] = idalabel SCREAMING_SNAKE_CASE_ : Dict = {v: k for k, v in idalabel.items()} if size == "b0": pass elif size == "b1": SCREAMING_SNAKE_CASE_ : Union[str, Any] = [64, 1_28, 3_20, 5_12] SCREAMING_SNAKE_CASE_ : int = 2_56 elif size == "b2": SCREAMING_SNAKE_CASE_ : Any = [64, 1_28, 3_20, 5_12] SCREAMING_SNAKE_CASE_ : Any = 7_68 SCREAMING_SNAKE_CASE_ : Any = [3, 4, 6, 3] elif size == "b3": SCREAMING_SNAKE_CASE_ : List[Any] = [64, 1_28, 3_20, 5_12] SCREAMING_SNAKE_CASE_ : str = 7_68 SCREAMING_SNAKE_CASE_ : List[Any] = [3, 4, 18, 3] elif size == "b4": SCREAMING_SNAKE_CASE_ : Optional[int] = [64, 1_28, 3_20, 5_12] SCREAMING_SNAKE_CASE_ : Any = 7_68 SCREAMING_SNAKE_CASE_ : int = [3, 8, 27, 3] elif size == "b5": SCREAMING_SNAKE_CASE_ : List[str] = [64, 1_28, 3_20, 5_12] SCREAMING_SNAKE_CASE_ : str = 7_68 SCREAMING_SNAKE_CASE_ : List[Any] = [3, 6, 40, 3] else: raise ValueError(f'Size {size} not supported' ) # load image processor (only resize + normalize) SCREAMING_SNAKE_CASE_ : int = SegformerImageProcessor( image_scale=(5_12, 5_12) , keep_ratio=snake_case_ , align=snake_case_ , do_random_crop=snake_case_ ) # prepare image SCREAMING_SNAKE_CASE_ : str = prepare_img() SCREAMING_SNAKE_CASE_ : Dict = image_processor(images=snake_case_ , return_tensors='''pt''' ).pixel_values logger.info(f'Converting model {model_name}...' ) # load original state dict if encoder_only: SCREAMING_SNAKE_CASE_ : Optional[int] = torch.load(snake_case_ , map_location=torch.device('''cpu''' ) ) else: SCREAMING_SNAKE_CASE_ : Any = torch.load(snake_case_ , map_location=torch.device('''cpu''' ) )['''state_dict'''] # rename keys SCREAMING_SNAKE_CASE_ : Tuple = rename_keys(snake_case_ , encoder_only=snake_case_ ) if not encoder_only: del state_dict["decode_head.conv_seg.weight"] del state_dict["decode_head.conv_seg.bias"] # key and value matrices need special treatment read_in_k_v(snake_case_ , snake_case_ ) # create HuggingFace model and load state dict if encoder_only: SCREAMING_SNAKE_CASE_ : int = False SCREAMING_SNAKE_CASE_ : Any = SegformerForImageClassification(snake_case_ ) else: SCREAMING_SNAKE_CASE_ : Optional[Any] = SegformerForSemanticSegmentation(snake_case_ ) model.load_state_dict(snake_case_ ) model.eval() # forward pass SCREAMING_SNAKE_CASE_ : Dict = model(snake_case_ ) SCREAMING_SNAKE_CASE_ : Optional[int] = outputs.logits # set expected_slice based on model name # ADE20k checkpoints if model_name == "segformer.b0.512x512.ade.160k": SCREAMING_SNAKE_CASE_ : Union[str, Any] = torch.tensor( [ [[-4.63_10, -5.52_32, -6.23_56], [-5.19_21, -6.14_44, -6.59_96], [-5.44_24, -6.27_90, -6.75_74]], [[-12.13_91, -13.31_22, -13.95_54], [-12.87_32, -13.93_52, -14.35_63], [-12.94_38, -13.82_26, -14.25_13]], [[-12.51_34, -13.46_86, -14.49_15], [-12.86_69, -14.43_43, -14.77_58], [-13.25_23, -14.58_19, -15.06_94]], ] ) elif model_name == "segformer.b1.512x512.ade.160k": SCREAMING_SNAKE_CASE_ : Dict = torch.tensor( [ [[-7.58_20, -8.72_31, -8.32_15], [-8.06_00, -10.35_29, -10.03_04], [-7.52_08, -9.41_03, -9.62_39]], [[-12.69_18, -13.89_94, -13.71_37], [-13.31_96, -15.75_23, -15.47_89], [-12.93_43, -14.87_57, -14.96_89]], [[-11.19_11, -11.94_21, -11.32_43], [-11.33_42, -13.68_39, -13.35_81], [-10.39_09, -12.18_32, -12.48_58]], ] ) elif model_name == "segformer.b2.512x512.ade.160k": SCREAMING_SNAKE_CASE_ : Tuple = torch.tensor( [ [[-11.81_73, -14.38_50, -16.31_28], [-14.56_48, -16.58_04, -18.65_68], [-14.72_23, -15.73_87, -18.42_18]], [[-15.72_90, -17.91_71, -19.44_23], [-18.31_05, -19.94_48, -21.46_61], [-17.92_96, -18.64_97, -20.79_10]], [[-15.07_83, -17.03_36, -18.27_89], [-16.87_71, -18.68_70, -20.16_12], [-16.24_54, -17.14_26, -19.50_55]], ] ) elif model_name == "segformer.b3.512x512.ade.160k": SCREAMING_SNAKE_CASE_ : int = torch.tensor( [ [[-9.08_78, -10.20_81, -10.18_91], [-9.31_44, -10.79_41, -10.98_43], [-9.22_94, -10.38_55, -10.57_04]], [[-12.23_16, -13.90_68, -13.61_02], [-12.91_61, -14.37_02, -14.32_35], [-12.52_33, -13.71_74, -13.79_32]], [[-14.62_75, -15.24_90, -14.97_27], [-14.34_00, -15.96_87, -16.28_27], [-14.14_84, -15.40_33, -15.89_37]], ] ) elif model_name == "segformer.b4.512x512.ade.160k": SCREAMING_SNAKE_CASE_ : List[str] = torch.tensor( [ [[-12.31_44, -13.24_47, -14.08_02], [-13.36_14, -14.58_16, -15.61_17], [-13.33_40, -14.44_33, -16.22_19]], [[-19.27_81, -20.41_28, -20.75_06], [-20.61_53, -21.65_66, -22.09_98], [-19.98_00, -21.04_30, -22.14_94]], [[-18.87_39, -19.78_04, -21.18_34], [-20.12_33, -21.67_65, -23.29_44], [-20.03_15, -21.26_41, -23.69_44]], ] ) elif model_name == "segformer.b5.640x640.ade.160k": SCREAMING_SNAKE_CASE_ : List[str] = torch.tensor( [ [[-9.55_24, -12.08_35, -11.73_48], [-10.52_29, -13.64_46, -14.56_62], [-9.58_42, -12.88_51, -13.94_14]], [[-15.34_32, -17.53_23, -17.08_18], [-16.33_30, -18.92_55, -19.21_01], [-15.13_40, -17.78_48, -18.39_71]], [[-12.60_72, -14.94_86, -14.66_31], [-13.76_29, -17.09_07, -17.77_45], [-12.78_99, -16.16_95, -17.16_71]], ] ) # Cityscapes checkpoints elif model_name == "segformer.b0.1024x1024.city.160k": SCREAMING_SNAKE_CASE_ : Dict = torch.tensor( [ [[-11.92_95, -13.40_57, -14.81_06], [-13.34_31, -14.81_79, -15.37_81], [-14.28_36, -15.59_42, -16.15_88]], [[-11.49_06, -12.80_67, -13.65_64], [-13.11_89, -14.05_00, -14.15_43], [-13.87_48, -14.51_36, -14.87_89]], [[0.53_74, 0.10_67, -0.47_42], [0.11_41, -0.22_55, -0.70_99], [-0.30_00, -0.59_24, -1.31_05]], ] ) elif model_name == "segformer.b0.512x1024.city.160k": SCREAMING_SNAKE_CASE_ : Tuple = torch.tensor( [ [[-7.82_17, -9.87_67, -10.17_17], [-9.44_38, -10.90_58, -11.40_47], [-9.79_39, -12.34_95, -12.10_79]], [[-7.15_14, -9.53_36, -10.08_60], [-9.77_76, -11.68_22, -11.84_39], [-10.14_11, -12.76_55, -12.89_72]], [[0.30_21, 0.08_05, -0.23_10], [-0.03_28, -0.16_05, -0.27_14], [-0.14_08, -0.54_77, -0.69_76]], ] ) elif model_name == "segformer.b0.640x1280.city.160k": SCREAMING_SNAKE_CASE_ : str = torch.tensor( [ [ [-1.1372e01, -1.2787e01, -1.3477e01], [-1.2536e01, -1.4194e01, -1.4409e01], [-1.3217e01, -1.4888e01, -1.5327e01], ], [ [-1.4791e01, -1.7122e01, -1.8277e01], [-1.7163e01, -1.9192e01, -1.9533e01], [-1.7897e01, -1.9991e01, -2.0315e01], ], [ [7.6723e-01, 4.1921e-01, -7.7878e-02], [4.7772e-01, 9.5557e-03, -2.8082e-01], [3.6032e-01, -2.4826e-01, -5.1168e-01], ], ] ) elif model_name == "segformer.b0.768x768.city.160k": SCREAMING_SNAKE_CASE_ : int = torch.tensor( [ [[-9.49_59, -11.30_87, -11.74_79], [-11.00_25, -12.65_40, -12.33_19], [-11.40_64, -13.04_87, -12.99_05]], [[-9.89_05, -11.30_84, -12.08_54], [-11.17_26, -12.76_98, -12.95_83], [-11.59_85, -13.32_78, -14.17_74]], [[0.22_13, 0.01_92, -0.24_66], [-0.17_31, -0.42_13, -0.48_74], [-0.31_26, -0.65_41, -1.13_89]], ] ) elif model_name == "segformer.b1.1024x1024.city.160k": SCREAMING_SNAKE_CASE_ : List[str] = torch.tensor( [ [[-13.57_48, -13.91_11, -12.65_00], [-14.35_00, -15.36_83, -14.23_28], [-14.75_32, -16.04_24, -15.60_87]], [[-17.16_51, -15.87_25, -12.96_53], [-17.25_80, -17.37_18, -14.82_23], [-16.60_58, -16.87_83, -16.74_52]], [[-3.64_56, -3.02_09, -1.42_03], [-3.07_97, -3.19_59, -2.00_00], [-1.87_57, -1.92_17, -1.69_97]], ] ) elif model_name == "segformer.b2.1024x1024.city.160k": SCREAMING_SNAKE_CASE_ : int = torch.tensor( [ [[-16.09_76, -16.48_56, -17.39_62], [-16.62_34, -19.03_42, -19.76_85], [-16.09_00, -18.06_61, -19.11_80]], [[-18.47_50, -18.84_88, -19.50_74], [-19.40_30, -22.15_70, -22.59_77], [-19.11_91, -20.84_86, -22.37_83]], [[-4.51_78, -5.50_37, -6.51_09], [-5.08_84, -7.21_74, -8.03_34], [-4.41_56, -5.81_17, -7.29_70]], ] ) elif model_name == "segformer.b3.1024x1024.city.160k": SCREAMING_SNAKE_CASE_ : Union[str, Any] = torch.tensor( [ [[-14.20_81, -14.47_32, -14.19_77], [-14.58_67, -16.44_23, -16.63_56], [-13.44_41, -14.96_85, -16.86_96]], [[-14.45_76, -14.70_73, -15.04_51], [-15.08_16, -17.62_37, -17.98_73], [-14.42_13, -16.01_99, -18.59_92]], [[-4.73_49, -4.95_88, -5.09_66], [-4.32_10, -6.93_25, -7.25_91], [-3.43_12, -4.74_84, -7.19_17]], ] ) elif model_name == "segformer.b4.1024x1024.city.160k": SCREAMING_SNAKE_CASE_ : Optional[int] = torch.tensor( [ [[-11.77_37, -11.95_26, -11.32_73], [-13.66_92, -14.45_74, -13.88_78], [-13.89_37, -14.69_24, -15.93_45]], [[-14.67_06, -14.53_30, -14.13_06], [-16.15_02, -16.81_80, -16.42_69], [-16.83_38, -17.89_39, -20.17_46]], [[1.04_91, 0.82_89, 1.03_10], [1.10_44, 0.52_19, 0.80_55], [1.08_99, 0.69_26, 0.55_90]], ] ) elif model_name == "segformer.b5.1024x1024.city.160k": SCREAMING_SNAKE_CASE_ : Tuple = torch.tensor( [ [[-12.56_41, -13.47_77, -13.06_84], [-13.95_87, -15.89_83, -16.65_57], [-13.31_09, -15.73_50, -16.31_41]], [[-14.70_74, -15.43_52, -14.59_44], [-16.63_53, -18.16_63, -18.61_20], [-15.17_02, -18.03_29, -18.15_47]], [[-1.79_90, -2.09_51, -1.77_84], [-2.63_97, -3.82_45, -3.96_86], [-1.52_64, -2.81_26, -2.93_16]], ] ) else: SCREAMING_SNAKE_CASE_ : Dict = logits.argmax(-1 ).item() print('''Predicted class:''' , model.config.idalabel[predicted_class_idx] ) # verify logits if not encoder_only: assert logits.shape == expected_shape assert torch.allclose(logits[0, :3, :3, :3] , snake_case_ , atol=1e-2 ) # finally, save model and image processor logger.info(f'Saving PyTorch model and image processor to {pytorch_dump_folder_path}...' ) Path(snake_case_ ).mkdir(exist_ok=snake_case_ ) model.save_pretrained(snake_case_ ) image_processor.save_pretrained(snake_case_ ) if __name__ == "__main__": UpperCAmelCase_ : Optional[Any] = argparse.ArgumentParser() parser.add_argument( """--model_name""", default="""segformer.b0.512x512.ade.160k""", type=str, help="""Name of the model you\'d like to convert.""", ) parser.add_argument( """--checkpoint_path""", default=None, type=str, help="""Path to the original PyTorch checkpoint (.pth file).""" ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the folder to output PyTorch model.""" ) UpperCAmelCase_ : Union[str, Any] = parser.parse_args() convert_segformer_checkpoint(args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path)
370
"""simple docstring""" from __future__ import annotations import queue class lowerCAmelCase__ : '''simple docstring''' def __init__( self : Tuple , lowercase_ : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = data SCREAMING_SNAKE_CASE_ : Tuple = None SCREAMING_SNAKE_CASE_ : Dict = None def _A () -> TreeNode: """simple docstring""" print('''\n********Press N to stop entering at any point of time********\n''' ) SCREAMING_SNAKE_CASE_ : List[Any] = input('''Enter the value of the root node: ''' ).strip().lower() SCREAMING_SNAKE_CASE_ : queue.Queue = queue.Queue() SCREAMING_SNAKE_CASE_ : Union[str, Any] = TreeNode(int(__a ) ) q.put(__a ) while not q.empty(): SCREAMING_SNAKE_CASE_ : Optional[int] = q.get() SCREAMING_SNAKE_CASE_ : List[str] = f'Enter the left node of {node_found.data}: ' SCREAMING_SNAKE_CASE_ : Optional[int] = input(__a ).strip().lower() or '''n''' if check == "n": return tree_node SCREAMING_SNAKE_CASE_ : List[str] = TreeNode(int(__a ) ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = left_node q.put(__a ) SCREAMING_SNAKE_CASE_ : str = f'Enter the right node of {node_found.data}: ' SCREAMING_SNAKE_CASE_ : str = input(__a ).strip().lower() or '''n''' if check == "n": return tree_node SCREAMING_SNAKE_CASE_ : Any = TreeNode(int(__a ) ) SCREAMING_SNAKE_CASE_ : int = right_node q.put(__a ) raise def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return print(node.data , end=''',''' ) pre_order(node.left ) pre_order(node.right ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return in_order(node.left ) print(node.data , end=''',''' ) in_order(node.right ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return post_order(node.left ) post_order(node.right ) print(node.data , end=''',''' ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ : queue.Queue = queue.Queue() q.put(__a ) while not q.empty(): SCREAMING_SNAKE_CASE_ : Tuple = q.get() print(node_dequeued.data , end=''',''' ) if node_dequeued.left: q.put(node_dequeued.left ) if node_dequeued.right: q.put(node_dequeued.right ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ : queue.Queue = queue.Queue() q.put(__a ) while not q.empty(): SCREAMING_SNAKE_CASE_ : str = [] while not q.empty(): SCREAMING_SNAKE_CASE_ : List[str] = q.get() print(node_dequeued.data , end=''',''' ) if node_dequeued.left: list_.append(node_dequeued.left ) if node_dequeued.right: list_.append(node_dequeued.right ) print() for node in list_: q.put(__a ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ : list[TreeNode] = [] SCREAMING_SNAKE_CASE_ : Union[str, Any] = node while n or stack: while n: # start from root node, find its left child print(n.data , end=''',''' ) stack.append(__a ) SCREAMING_SNAKE_CASE_ : Optional[Any] = n.left # end of while means current node doesn't have left child SCREAMING_SNAKE_CASE_ : Tuple = stack.pop() # start to traverse its right child SCREAMING_SNAKE_CASE_ : str = n.right def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ : list[TreeNode] = [] SCREAMING_SNAKE_CASE_ : Any = node while n or stack: while n: stack.append(__a ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = n.left SCREAMING_SNAKE_CASE_ : Any = stack.pop() print(n.data , end=''',''' ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = n.right def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Any = [], [] SCREAMING_SNAKE_CASE_ : List[Any] = node stacka.append(__a ) while stacka: # to find the reversed order of post order, store it in stack2 SCREAMING_SNAKE_CASE_ : List[str] = stacka.pop() if n.left: stacka.append(n.left ) if n.right: stacka.append(n.right ) stacka.append(__a ) while stacka: # pop up from stack2 will be the post order print(stacka.pop().data , end=''',''' ) def _A (__a = "" , __a=50 , __a="*" ) -> str: """simple docstring""" if not s: return "\n" + width * char SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Dict = divmod(width - len(__a ) - 2 , 2 ) return f'{left * char} {s} {(left + extra) * char}' if __name__ == "__main__": import doctest doctest.testmod() print(prompt("""Binary Tree Traversals""")) UpperCAmelCase_ : TreeNode = build_tree() print(prompt("""Pre Order Traversal""")) pre_order(node) print(prompt() + """\n""") print(prompt("""In Order Traversal""")) in_order(node) print(prompt() + """\n""") print(prompt("""Post Order Traversal""")) post_order(node) print(prompt() + """\n""") print(prompt("""Level Order Traversal""")) level_order(node) print(prompt() + """\n""") print(prompt("""Actual Level Order Traversal""")) level_order_actual(node) print("""*""" * 50 + """\n""") print(prompt("""Pre Order Traversal - Iteration Version""")) pre_order_iter(node) print(prompt() + """\n""") print(prompt("""In Order Traversal - Iteration Version""")) in_order_iter(node) print(prompt() + """\n""") print(prompt("""Post Order Traversal - Iteration Version""")) post_order_iter(node) print(prompt())
318
0
"""simple docstring""" from __future__ import annotations import csv import requests from bsa import BeautifulSoup def _A (__a = "" ) -> Optional[int]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Any = url or '''https://www.imdb.com/chart/top/?ref_=nv_mv_250''' SCREAMING_SNAKE_CASE_ : List[Any] = BeautifulSoup(requests.get(a__ ).text , '''html.parser''' ) SCREAMING_SNAKE_CASE_ : List[str] = soup.find_all('''td''' , attrs='''titleColumn''' ) SCREAMING_SNAKE_CASE_ : Optional[int] = soup.find_all('''td''' , class_='''ratingColumn imdbRating''' ) return { title.a.text: float(rating.strong.text ) for title, rating in zip(a__ , a__ ) } def _A (__a = "IMDb_Top_250_Movies.csv" ) -> Any: """simple docstring""" SCREAMING_SNAKE_CASE_ : str = get_imdb_top_aaa_movies() with open(a__ , '''w''' , newline='''''' ) as out_file: SCREAMING_SNAKE_CASE_ : Tuple = csv.writer(a__ ) writer.writerow(['''Movie title''', '''IMDb rating'''] ) for title, rating in movies.items(): writer.writerow([title, rating] ) if __name__ == "__main__": write_movies()
371
"""simple docstring""" import random import unittest import numpy as np import torch from diffusers import ( DPMSolverMultistepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, LMSDiscreteScheduler, OnnxStableDiffusionUpscalePipeline, PNDMScheduler, ) from diffusers.utils import floats_tensor from diffusers.utils.testing_utils import ( is_onnx_available, load_image, nightly, require_onnxruntime, require_torch_gpu, ) from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin if is_onnx_available(): import onnxruntime as ort class lowerCAmelCase__ ( UpperCAmelCase__ , unittest.TestCase ): '''simple docstring''' __UpperCamelCase = "ssube/stable-diffusion-x4-upscaler-onnx" def _SCREAMING_SNAKE_CASE ( self : Optional[int] , lowercase_ : Union[str, Any]=0): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = floats_tensor((1, 3, 128, 128) , rng=random.Random(lowercase_)) SCREAMING_SNAKE_CASE_ : List[str] = torch.manual_seed(lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = { '''prompt''': '''A painting of a squirrel eating a burger''', '''image''': image, '''generator''': generator, '''num_inference_steps''': 3, '''guidance_scale''': 7.5, '''output_type''': '''numpy''', } return inputs def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''') pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : Tuple = self.get_dummy_inputs() SCREAMING_SNAKE_CASE_ : Union[str, Any] = pipe(**lowercase_).images SCREAMING_SNAKE_CASE_ : Dict = image[0, -3:, -3:, -1].flatten() # started as 128, should now be 512 assert image.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : Any = np.array( [0.6_97_47_82, 0.68_90_20_93, 0.70_13_58_85, 0.7_58_36_18, 0.7_80_45_45, 0.7_85_49_12, 0.78_66_74_26, 0.78_74_38_63, 0.78_07_02_23]) assert np.abs(image_slice - expected_slice).max() < 1e-1 def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''') SCREAMING_SNAKE_CASE_ : Optional[int] = PNDMScheduler.from_config(pipe.scheduler.config , skip_prk_steps=lowercase_) pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : Any = self.get_dummy_inputs() SCREAMING_SNAKE_CASE_ : Optional[Any] = pipe(**lowercase_).images SCREAMING_SNAKE_CASE_ : int = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : Any = np.array( [0.6_89_88_92, 0.59_24_05_56, 0.52_49_95_27, 0.58_86_62_15, 0.52_25_82_35, 0.52_57_27_15, 0.62_41_44_73, 0.6_17_43_87, 0.6_21_49_64]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-1 def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''') SCREAMING_SNAKE_CASE_ : Union[str, Any] = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = self.get_dummy_inputs() SCREAMING_SNAKE_CASE_ : Tuple = pipe(**lowercase_).images SCREAMING_SNAKE_CASE_ : Union[str, Any] = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : Tuple = np.array( [0.7_65_92_78, 0.76_43_76_64, 0.75_57_91_07, 0.7_69_11_16, 0.77_66_69_86, 0.7_72_76_72, 0.7_75_86_64, 0.7_81_22_26, 0.76_94_25_15]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-1 def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''') SCREAMING_SNAKE_CASE_ : List[Any] = EulerDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : Any = self.get_dummy_inputs() SCREAMING_SNAKE_CASE_ : Optional[Any] = pipe(**lowercase_).images SCREAMING_SNAKE_CASE_ : Optional[int] = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : Optional[Any] = np.array( [0.6_97_47_82, 0.68_90_20_93, 0.70_13_58_85, 0.7_58_36_18, 0.7_80_45_45, 0.7_85_49_12, 0.78_66_74_26, 0.78_74_38_63, 0.78_07_02_23]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-1 def _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''') SCREAMING_SNAKE_CASE_ : int = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = self.get_dummy_inputs() SCREAMING_SNAKE_CASE_ : Optional[int] = pipe(**lowercase_).images SCREAMING_SNAKE_CASE_ : str = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : int = np.array( [0.77_42_44_96, 0.77_36_01, 0.7_64_52_88, 0.7_76_95_98, 0.7_77_27_39, 0.7_73_86_88, 0.78_18_72_33, 0.77_87_95_84, 0.76_70_43]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-1 @nightly @require_onnxruntime @require_torch_gpu class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' @property def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' return ( "CUDAExecutionProvider", { "gpu_mem_limit": "15000000000", # 15GB "arena_extend_strategy": "kSameAsRequested", }, ) @property def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = ort.SessionOptions() SCREAMING_SNAKE_CASE_ : Optional[int] = False return options def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = load_image( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/img2img/sketch-mountains-input.jpg''') SCREAMING_SNAKE_CASE_ : Tuple = init_image.resize((128, 128)) # using the PNDM scheduler by default SCREAMING_SNAKE_CASE_ : List[str] = OnnxStableDiffusionUpscalePipeline.from_pretrained( '''ssube/stable-diffusion-x4-upscaler-onnx''' , provider=self.gpu_provider , sess_options=self.gpu_options , ) pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : Union[str, Any] = '''A fantasy landscape, trending on artstation''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = torch.manual_seed(0) SCREAMING_SNAKE_CASE_ : List[Any] = pipe( prompt=lowercase_ , image=lowercase_ , guidance_scale=7.5 , num_inference_steps=10 , generator=lowercase_ , output_type='''np''' , ) SCREAMING_SNAKE_CASE_ : Optional[int] = output.images SCREAMING_SNAKE_CASE_ : Optional[int] = images[0, 255:258, 383:386, -1] assert images.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : int = np.array([0.48_83, 0.49_47, 0.49_80, 0.49_75, 0.49_82, 0.49_80, 0.50_00, 0.50_06, 0.49_72]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2e-2 def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = load_image( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/img2img/sketch-mountains-input.jpg''') SCREAMING_SNAKE_CASE_ : Tuple = init_image.resize((128, 128)) SCREAMING_SNAKE_CASE_ : Tuple = LMSDiscreteScheduler.from_pretrained( '''ssube/stable-diffusion-x4-upscaler-onnx''' , subfolder='''scheduler''') SCREAMING_SNAKE_CASE_ : str = OnnxStableDiffusionUpscalePipeline.from_pretrained( '''ssube/stable-diffusion-x4-upscaler-onnx''' , scheduler=lowercase_ , provider=self.gpu_provider , sess_options=self.gpu_options , ) pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : int = '''A fantasy landscape, trending on artstation''' SCREAMING_SNAKE_CASE_ : List[Any] = torch.manual_seed(0) SCREAMING_SNAKE_CASE_ : int = pipe( prompt=lowercase_ , image=lowercase_ , guidance_scale=7.5 , num_inference_steps=20 , generator=lowercase_ , output_type='''np''' , ) SCREAMING_SNAKE_CASE_ : Optional[int] = output.images SCREAMING_SNAKE_CASE_ : Dict = images[0, 255:258, 383:386, -1] assert images.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : List[str] = np.array( [0.50_17_37_53, 0.50_22_33_56, 0.50_20_39, 0.50_23_30_36, 0.5_02_37_25, 0.5_02_26_01, 0.5_01_87_58, 0.50_23_40_85, 0.50_24_15_66]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2e-2
318
0
"""simple docstring""" import contextlib from multiprocessing import Pool, RLock from tqdm.auto import tqdm from ..utils import experimental, logging UpperCAmelCase_ : Tuple = logging.get_logger(__name__) class lowerCAmelCase__ : '''simple docstring''' __UpperCamelCase = None @experimental def _A (__a , __a , __a , __a , __a , __a , __a ) -> Union[str, Any]: """simple docstring""" if ParallelBackendConfig.backend_name is None: return _map_with_multiprocessing_pool( __a , __a , __a , __a , __a , __a , __a ) return _map_with_joblib(__a , __a , __a , __a , __a , __a , __a ) def _A (__a , __a , __a , __a , __a , __a , __a ) -> List[str]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[Any] = num_proc if num_proc <= len(__a ) else len(__a ) SCREAMING_SNAKE_CASE_ : Tuple = [] # We organize the splits ourselve (contiguous splits) for index in range(__a ): SCREAMING_SNAKE_CASE_ : List[str] = len(__a ) // num_proc SCREAMING_SNAKE_CASE_ : int = len(__a ) % num_proc SCREAMING_SNAKE_CASE_ : List[str] = div * index + min(__a , __a ) SCREAMING_SNAKE_CASE_ : str = start + div + (1 if index < mod else 0) split_kwds.append((function, iterable[start:end], types, index, disable_tqdm, desc) ) if len(__a ) != sum(len(i[1] ) for i in split_kwds ): raise ValueError( f'Error dividing inputs iterable among processes. ' f'Total number of objects {len(__a )}, ' f'length: {sum(len(i[1] ) for i in split_kwds )}' ) logger.info( f'Spawning {num_proc} processes for {len(__a )} objects in slices of {[len(i[1] ) for i in split_kwds]}' ) SCREAMING_SNAKE_CASE_ : Optional[int] = None, None if not disable_tqdm: SCREAMING_SNAKE_CASE_ : Optional[Any] = (RLock(),), tqdm.set_lock with Pool(__a , initargs=__a , initializer=__a ) as pool: SCREAMING_SNAKE_CASE_ : Dict = pool.map(__a , __a ) logger.info(f'Finished {num_proc} processes' ) SCREAMING_SNAKE_CASE_ : Any = [obj for proc_res in mapped for obj in proc_res] logger.info(f'Unpacked {len(__a )} objects' ) return mapped def _A (__a , __a , __a , __a , __a , __a , __a ) -> Optional[int]: """simple docstring""" import joblib with joblib.parallel_backend(ParallelBackendConfig.backend_name , n_jobs=__a ): return joblib.Parallel()( joblib.delayed(__a )((function, obj, types, None, True, None) ) for obj in iterable ) @experimental @contextlib.contextmanager def _A (__a ) -> List[Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Any = backend_name if backend_name == "spark": from joblibspark import register_spark register_spark() # TODO: call create_cache_and_write_probe if "download" in steps # TODO: raise NotImplementedError when Dataset.map etc is called try: yield finally: SCREAMING_SNAKE_CASE_ : Tuple = None
350
"""simple docstring""" from scipy.stats import pearsonr import datasets UpperCAmelCase_ : List[Any] = """ Pearson correlation coefficient and p-value for testing non-correlation. The Pearson correlation coefficient measures the linear relationship between two datasets. The calculation of the p-value relies on the assumption that each dataset is normally distributed. Like other correlation coefficients, this one varies between -1 and +1 with 0 implying no correlation. Correlations of -1 or +1 imply an exact linear relationship. Positive correlations imply that as x increases, so does y. Negative correlations imply that as x increases, y decreases. The p-value roughly indicates the probability of an uncorrelated system producing datasets that have a Pearson correlation at least as extreme as the one computed from these datasets. """ UpperCAmelCase_ : Optional[int] = """ Args: predictions (`list` of `int`): Predicted class labels, as returned by a model. references (`list` of `int`): Ground truth labels. return_pvalue (`boolean`): If `True`, returns the p-value, along with the correlation coefficient. If `False`, returns only the correlation coefficient. Defaults to `False`. Returns: pearsonr (`float`): Pearson correlation coefficient. Minimum possible value is -1. Maximum possible value is 1. Values of 1 and -1 indicate exact linear positive and negative relationships, respectively. A value of 0 implies no correlation. p-value (`float`): P-value, which roughly indicates the probability of an The p-value roughly indicates the probability of an uncorrelated system producing datasets that have a Pearson correlation at least as extreme as the one computed from these datasets. Minimum possible value is 0. Maximum possible value is 1. Higher values indicate higher probabilities. Examples: Example 1-A simple example using only predictions and references. >>> pearsonr_metric = datasets.load_metric(\"pearsonr\") >>> results = pearsonr_metric.compute(predictions=[10, 9, 2.5, 6, 4], references=[1, 2, 3, 4, 5]) >>> print(round(results['pearsonr'], 2)) -0.74 Example 2-The same as Example 1, but that also returns the `p-value`. >>> pearsonr_metric = datasets.load_metric(\"pearsonr\") >>> results = pearsonr_metric.compute(predictions=[10, 9, 2.5, 6, 4], references=[1, 2, 3, 4, 5], return_pvalue=True) >>> print(sorted(list(results.keys()))) ['p-value', 'pearsonr'] >>> print(round(results['pearsonr'], 2)) -0.74 >>> print(round(results['p-value'], 2)) 0.15 """ UpperCAmelCase_ : Tuple = """ @article{2020SciPy-NMeth, author = {Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E. and Haberland, Matt and Reddy, Tyler and Cournapeau, David and Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and Bright, Jonathan and {van der Walt}, St{\'e}fan J. and Brett, Matthew and Wilson, Joshua and Millman, K. Jarrod and Mayorov, Nikolay and Nelson, Andrew R. J. and Jones, Eric and Kern, Robert and Larson, Eric and Carey, C J and Polat, Ilhan and Feng, Yu and Moore, Eric W. and {VanderPlas}, Jake and Laxalde, Denis and Perktold, Josef and Cimrman, Robert and Henriksen, Ian and Quintero, E. A. and Harris, Charles R. and Archibald, Anne M. and Ribeiro, Antonio H. and Pedregosa, Fabian and {van Mulbregt}, Paul and {SciPy 1.0 Contributors}}, title = {{{SciPy} 1.0: Fundamental Algorithms for Scientific Computing in Python}}, journal = {Nature Methods}, year = {2020}, volume = {17}, pages = {261--272}, adsurl = {https://rdcu.be/b08Wh}, doi = {10.1038/s41592-019-0686-2}, } """ @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class lowerCAmelCase__ ( datasets.Metric ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { '''predictions''': datasets.Value('''float'''), '''references''': datasets.Value('''float'''), }) , reference_urls=['''https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.pearsonr.html'''] , ) def _SCREAMING_SNAKE_CASE ( self : List[Any] , lowercase_ : List[str] , lowercase_ : List[Any] , lowercase_ : Union[str, Any]=False): '''simple docstring''' if return_pvalue: SCREAMING_SNAKE_CASE_ : int = pearsonr(lowercase_ , lowercase_) return {"pearsonr": results[0], "p-value": results[1]} else: return {"pearsonr": float(pearsonr(lowercase_ , lowercase_)[0])}
318
0
"""simple docstring""" UpperCAmelCase_ : Any = tuple[float, float, float] UpperCAmelCase_ : Optional[Any] = tuple[float, float, float] def _A (__a , __a ) -> Optional[Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Tuple = end_pointa[0] - end_pointa[0] SCREAMING_SNAKE_CASE_ : Optional[Any] = end_pointa[1] - end_pointa[1] SCREAMING_SNAKE_CASE_ : Optional[Any] = end_pointa[2] - end_pointa[2] return (x, y, z) def _A (__a , __a ) -> Tuple: """simple docstring""" SCREAMING_SNAKE_CASE_ : Union[str, Any] = ab[1] * ac[2] - ab[2] * ac[1] # *i SCREAMING_SNAKE_CASE_ : str = (ab[0] * ac[2] - ab[2] * ac[0]) * -1 # *j SCREAMING_SNAKE_CASE_ : List[str] = ab[0] * ac[1] - ab[1] * ac[0] # *k return (x, y, z) def _A (__a , __a ) -> Dict: """simple docstring""" return tuple(round(A__ , A__ ) for x in vector ) == (0, 0, 0) def _A (__a , __a , __a , __a = 10 ) -> Union[str, Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Any = create_vector(A__ , A__ ) SCREAMING_SNAKE_CASE_ : Optional[Any] = create_vector(A__ , A__ ) return is_zero_vector(get_ad_vectors_cross(A__ , A__ ) , A__ )
351
"""simple docstring""" import os from typing import Dict, List, Union import tensorflow as tf from keras_nlp.tokenizers import BytePairTokenizer from tensorflow_text import pad_model_inputs from .tokenization_gpta import GPTaTokenizer class lowerCAmelCase__ ( tf.keras.layers.Layer ): '''simple docstring''' def __init__( self : Any , lowercase_ : Dict[str, int] , lowercase_ : List[str] , lowercase_ : int = None , lowercase_ : int = None): '''simple docstring''' super().__init__() SCREAMING_SNAKE_CASE_ : str = pad_token_id SCREAMING_SNAKE_CASE_ : Optional[int] = max_length SCREAMING_SNAKE_CASE_ : Dict = vocab SCREAMING_SNAKE_CASE_ : Dict = merges SCREAMING_SNAKE_CASE_ : Union[str, Any] = BytePairTokenizer(lowercase_ , lowercase_ , sequence_length=lowercase_) @classmethod def _SCREAMING_SNAKE_CASE ( cls : Dict , lowercase_ : GPTaTokenizer , *lowercase_ : Optional[Any] , **lowercase_ : Tuple): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = [''' '''.join(lowercase_) for m in tokenizer.bpe_ranks.keys()] SCREAMING_SNAKE_CASE_ : str = tokenizer.get_vocab() return cls(lowercase_ , lowercase_ , *lowercase_ , **lowercase_) @classmethod def _SCREAMING_SNAKE_CASE ( cls : int , lowercase_ : Union[str, os.PathLike] , *lowercase_ : List[str] , **lowercase_ : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = GPTaTokenizer.from_pretrained(lowercase_ , *lowercase_ , **lowercase_) return cls.from_tokenizer(lowercase_ , *lowercase_ , **lowercase_) @classmethod def _SCREAMING_SNAKE_CASE ( cls : Dict , lowercase_ : List[Any]): '''simple docstring''' return cls(**lowercase_) def _SCREAMING_SNAKE_CASE ( self : Tuple): '''simple docstring''' return { "vocab": self.vocab, "merges": self.merges, "max_length": self.max_length, "pad_token_id": self.pad_token_id, } def _SCREAMING_SNAKE_CASE ( self : Any , lowercase_ : List[Any] , lowercase_ : int = None): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = self.tf_tokenizer(lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = tf.ones_like(lowercase_) if self.pad_token_id is not None: # pad the tokens up to max length SCREAMING_SNAKE_CASE_ : Union[str, Any] = max_length if max_length is not None else self.max_length if max_length is not None: SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : List[str] = pad_model_inputs( lowercase_ , max_seq_length=lowercase_ , pad_value=self.pad_token_id) return {"attention_mask": attention_mask, "input_ids": input_ids}
318
0
"""simple docstring""" from math import ceil, sqrt def _A (__a = 1_00_00_00 ) -> Optional[int]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Union[str, Any] = 0 for outer_width in range(3 , (limit // 4) + 2 ): if outer_width**2 > limit: SCREAMING_SNAKE_CASE_ : List[str] = max(ceil(sqrt(outer_width**2 - limit ) ) , 1 ) else: SCREAMING_SNAKE_CASE_ : Optional[Any] = 1 if (outer_width - hole_width_lower_bound) % 2: hole_width_lower_bound += 1 answer += (outer_width - hole_width_lower_bound - 2) // 2 + 1 return answer if __name__ == "__main__": print(f'''{solution() = }''')
352
"""simple docstring""" import json import os import shutil import tempfile import unittest import numpy as np import pytest from transformers import BertTokenizer, BertTokenizerFast from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES from transformers.testing_utils import require_vision from transformers.utils import FEATURE_EXTRACTOR_NAME, is_vision_available if is_vision_available(): from PIL import Image from transformers import ChineseCLIPImageProcessor, ChineseCLIPProcessor @require_vision class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = tempfile.mkdtemp() SCREAMING_SNAKE_CASE_ : Union[str, Any] = [ '''[UNK]''', '''[CLS]''', '''[SEP]''', '''[PAD]''', '''[MASK]''', '''的''', '''价''', '''格''', '''是''', '''15''', '''便''', '''alex''', '''##andra''', ''',''', '''。''', '''-''', '''t''', '''shirt''', ] SCREAMING_SNAKE_CASE_ : int = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['''vocab_file''']) with open(self.vocab_file , '''w''' , encoding='''utf-8''') as vocab_writer: vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens])) SCREAMING_SNAKE_CASE_ : Dict = { '''do_resize''': True, '''size''': {'''height''': 224, '''width''': 224}, '''do_center_crop''': True, '''crop_size''': {'''height''': 18, '''width''': 18}, '''do_normalize''': True, '''image_mean''': [0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73], '''image_std''': [0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11], '''do_convert_rgb''': True, } SCREAMING_SNAKE_CASE_ : int = os.path.join(self.tmpdirname , lowercase_) with open(self.image_processor_file , '''w''' , encoding='''utf-8''') as fp: json.dump(lowercase_ , lowercase_) def _SCREAMING_SNAKE_CASE ( self : Optional[int] , **lowercase_ : str): '''simple docstring''' return BertTokenizer.from_pretrained(self.tmpdirname , **lowercase_) def _SCREAMING_SNAKE_CASE ( self : Tuple , **lowercase_ : List[Any]): '''simple docstring''' return BertTokenizerFast.from_pretrained(self.tmpdirname , **lowercase_) def _SCREAMING_SNAKE_CASE ( self : List[Any] , **lowercase_ : str): '''simple docstring''' return ChineseCLIPImageProcessor.from_pretrained(self.tmpdirname , **lowercase_) def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' shutil.rmtree(self.tmpdirname) def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = [np.random.randint(255 , size=(3, 30, 400) , dtype=np.uinta)] SCREAMING_SNAKE_CASE_ : Dict = [Image.fromarray(np.moveaxis(lowercase_ , 0 , -1)) for x in image_inputs] return image_inputs def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.get_rust_tokenizer() SCREAMING_SNAKE_CASE_ : Any = self.get_image_processor() SCREAMING_SNAKE_CASE_ : int = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) processor_slow.save_pretrained(self.tmpdirname) SCREAMING_SNAKE_CASE_ : Optional[int] = ChineseCLIPProcessor.from_pretrained(self.tmpdirname , use_fast=lowercase_) SCREAMING_SNAKE_CASE_ : Any = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) processor_fast.save_pretrained(self.tmpdirname) SCREAMING_SNAKE_CASE_ : int = ChineseCLIPProcessor.from_pretrained(self.tmpdirname) self.assertEqual(processor_slow.tokenizer.get_vocab() , tokenizer_slow.get_vocab()) self.assertEqual(processor_fast.tokenizer.get_vocab() , tokenizer_fast.get_vocab()) self.assertEqual(tokenizer_slow.get_vocab() , tokenizer_fast.get_vocab()) self.assertIsInstance(processor_slow.tokenizer , lowercase_) self.assertIsInstance(processor_fast.tokenizer , lowercase_) self.assertEqual(processor_slow.image_processor.to_json_string() , image_processor.to_json_string()) self.assertEqual(processor_fast.image_processor.to_json_string() , image_processor.to_json_string()) self.assertIsInstance(processor_slow.image_processor , lowercase_) self.assertIsInstance(processor_fast.image_processor , lowercase_) def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = ChineseCLIPProcessor(tokenizer=self.get_tokenizer() , image_processor=self.get_image_processor()) processor.save_pretrained(self.tmpdirname) SCREAMING_SNAKE_CASE_ : Optional[int] = self.get_tokenizer(cls_token='''(CLS)''' , sep_token='''(SEP)''') SCREAMING_SNAKE_CASE_ : Optional[int] = self.get_image_processor(do_normalize=lowercase_) SCREAMING_SNAKE_CASE_ : Tuple = ChineseCLIPProcessor.from_pretrained( self.tmpdirname , cls_token='''(CLS)''' , sep_token='''(SEP)''' , do_normalize=lowercase_) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab()) self.assertIsInstance(processor.tokenizer , lowercase_) self.assertEqual(processor.image_processor.to_json_string() , image_processor_add_kwargs.to_json_string()) self.assertIsInstance(processor.image_processor , lowercase_) def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = self.get_image_processor() SCREAMING_SNAKE_CASE_ : List[Any] = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : Tuple = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = self.prepare_image_inputs() SCREAMING_SNAKE_CASE_ : Any = image_processor(lowercase_ , return_tensors='''np''') SCREAMING_SNAKE_CASE_ : Union[str, Any] = processor(images=lowercase_ , return_tensors='''np''') for key in input_feat_extract.keys(): self.assertAlmostEqual(input_feat_extract[key].sum() , input_processor[key].sum() , delta=1e-2) def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = self.get_image_processor() SCREAMING_SNAKE_CASE_ : Any = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : str = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) SCREAMING_SNAKE_CASE_ : Dict = '''Alexandra,T-shirt的价格是15便士。''' SCREAMING_SNAKE_CASE_ : Optional[Any] = processor(text=lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = tokenizer(lowercase_) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key]) def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = self.get_image_processor() SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : int = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) SCREAMING_SNAKE_CASE_ : Union[str, Any] = '''Alexandra,T-shirt的价格是15便士。''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.prepare_image_inputs() SCREAMING_SNAKE_CASE_ : int = processor(text=lowercase_ , images=lowercase_) self.assertListEqual(list(inputs.keys()) , ['''input_ids''', '''token_type_ids''', '''attention_mask''', '''pixel_values''']) # test if it raises when no input is passed with pytest.raises(lowercase_): processor() def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.get_image_processor() SCREAMING_SNAKE_CASE_ : List[Any] = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : Optional[int] = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) SCREAMING_SNAKE_CASE_ : Any = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] SCREAMING_SNAKE_CASE_ : Optional[int] = processor.batch_decode(lowercase_) SCREAMING_SNAKE_CASE_ : Dict = tokenizer.batch_decode(lowercase_) self.assertListEqual(lowercase_ , lowercase_) def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = self.get_image_processor() SCREAMING_SNAKE_CASE_ : Dict = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : Dict = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = '''Alexandra,T-shirt的价格是15便士。''' SCREAMING_SNAKE_CASE_ : Dict = self.prepare_image_inputs() SCREAMING_SNAKE_CASE_ : Dict = processor(text=lowercase_ , images=lowercase_) self.assertListEqual(list(inputs.keys()) , processor.model_input_names)
318
0
"""simple docstring""" import random from typing import Any def _A (__a ) -> Dict: """simple docstring""" for _ in range(len(__a ) ): SCREAMING_SNAKE_CASE_ : Optional[Any] = random.randint(0 , len(__a ) - 1 ) SCREAMING_SNAKE_CASE_ : Tuple = random.randint(0 , len(__a ) - 1 ) SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Union[str, Any] = data[b], data[a] return data if __name__ == "__main__": UpperCAmelCase_ : Union[str, Any] = [0, 1, 2, 3, 4, 5, 6, 7] UpperCAmelCase_ : Optional[int] = ["""python""", """says""", """hello""", """!"""] print("""Fisher-Yates Shuffle:""") print("""List""", integers, strings) print("""FY Shuffle""", fisher_yates_shuffle(integers), fisher_yates_shuffle(strings))
353
"""simple docstring""" from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCAmelCase_ : Dict = logging.get_logger(__name__) UpperCAmelCase_ : List[str] = { """RWKV/rwkv-4-169m-pile""": """https://huggingface.co/RWKV/rwkv-4-169m-pile/resolve/main/config.json""", """RWKV/rwkv-4-430m-pile""": """https://huggingface.co/RWKV/rwkv-4-430m-pile/resolve/main/config.json""", """RWKV/rwkv-4-1b5-pile""": """https://huggingface.co/RWKV/rwkv-4-1b5-pile/resolve/main/config.json""", """RWKV/rwkv-4-3b-pile""": """https://huggingface.co/RWKV/rwkv-4-3b-pile/resolve/main/config.json""", """RWKV/rwkv-4-7b-pile""": """https://huggingface.co/RWKV/rwkv-4-7b-pile/resolve/main/config.json""", """RWKV/rwkv-4-14b-pile""": """https://huggingface.co/RWKV/rwkv-4-14b-pile/resolve/main/config.json""", """RWKV/rwkv-raven-1b5""": """https://huggingface.co/RWKV/rwkv-raven-1b5/resolve/main/config.json""", """RWKV/rwkv-raven-3b""": """https://huggingface.co/RWKV/rwkv-raven-3b/resolve/main/config.json""", """RWKV/rwkv-raven-7b""": """https://huggingface.co/RWKV/rwkv-raven-7b/resolve/main/config.json""", """RWKV/rwkv-raven-14b""": """https://huggingface.co/RWKV/rwkv-raven-14b/resolve/main/config.json""", } class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = "rwkv" __UpperCamelCase = {"max_position_embeddings": "context_length"} def __init__( self : Union[str, Any] , lowercase_ : Any=50277 , lowercase_ : str=1024 , lowercase_ : List[str]=4096 , lowercase_ : Optional[Any]=32 , lowercase_ : Any=None , lowercase_ : Any=None , lowercase_ : List[Any]=1e-5 , lowercase_ : Union[str, Any]=0 , lowercase_ : Union[str, Any]=0 , lowercase_ : int=6 , lowercase_ : Tuple=False , lowercase_ : Any=True , **lowercase_ : Any , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = vocab_size SCREAMING_SNAKE_CASE_ : Any = context_length SCREAMING_SNAKE_CASE_ : int = hidden_size SCREAMING_SNAKE_CASE_ : int = num_hidden_layers SCREAMING_SNAKE_CASE_ : List[str] = attention_hidden_size if attention_hidden_size is not None else hidden_size SCREAMING_SNAKE_CASE_ : int = intermediate_size if intermediate_size is not None else 4 * hidden_size SCREAMING_SNAKE_CASE_ : int = layer_norm_epsilon SCREAMING_SNAKE_CASE_ : Optional[int] = rescale_every SCREAMING_SNAKE_CASE_ : Dict = use_cache SCREAMING_SNAKE_CASE_ : Dict = bos_token_id SCREAMING_SNAKE_CASE_ : Any = eos_token_id super().__init__( tie_word_embeddings=lowercase_ , bos_token_id=lowercase_ , eos_token_id=lowercase_ , **lowercase_)
318
0
"""simple docstring""" from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCAmelCase_ = logging.get_logger(__name__) UpperCAmelCase_ = { "edbeeching/decision-transformer-gym-hopper-medium": ( "https://huggingface.co/edbeeching/decision-transformer-gym-hopper-medium/resolve/main/config.json" ), # See all DecisionTransformer models at https://huggingface.co/models?filter=decision_transformer } class lowerCAmelCase__ ( lowercase_ ): '''simple docstring''' __UpperCamelCase = "decision_transformer" __UpperCamelCase = ["past_key_values"] __UpperCamelCase = { "max_position_embeddings": "n_positions", "num_attention_heads": "n_head", "num_hidden_layers": "n_layer", } def __init__( self : Optional[Any] , lowercase_ : Optional[Any]=17 , lowercase_ : List[Any]=4 , lowercase_ : Dict=128 , lowercase_ : Dict=4096 , lowercase_ : str=True , lowercase_ : Dict=1 , lowercase_ : int=1024 , lowercase_ : int=3 , lowercase_ : Dict=1 , lowercase_ : str=None , lowercase_ : Optional[Any]="relu" , lowercase_ : Optional[int]=0.1 , lowercase_ : str=0.1 , lowercase_ : List[str]=0.1 , lowercase_ : str=1e-5 , lowercase_ : int=0.02 , lowercase_ : Any=True , lowercase_ : int=True , lowercase_ : str=50256 , lowercase_ : List[str]=50256 , lowercase_ : List[Any]=False , lowercase_ : Any=False , **lowercase_ : Union[str, Any] , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = state_dim SCREAMING_SNAKE_CASE_ : List[str] = act_dim SCREAMING_SNAKE_CASE_ : int = hidden_size SCREAMING_SNAKE_CASE_ : List[Any] = max_ep_len SCREAMING_SNAKE_CASE_ : int = action_tanh SCREAMING_SNAKE_CASE_ : Tuple = vocab_size SCREAMING_SNAKE_CASE_ : Tuple = n_positions SCREAMING_SNAKE_CASE_ : Union[str, Any] = n_layer SCREAMING_SNAKE_CASE_ : Any = n_head SCREAMING_SNAKE_CASE_ : Optional[Any] = n_inner SCREAMING_SNAKE_CASE_ : Optional[Any] = activation_function SCREAMING_SNAKE_CASE_ : Optional[Any] = resid_pdrop SCREAMING_SNAKE_CASE_ : Tuple = embd_pdrop SCREAMING_SNAKE_CASE_ : Optional[int] = attn_pdrop SCREAMING_SNAKE_CASE_ : Union[str, Any] = layer_norm_epsilon SCREAMING_SNAKE_CASE_ : Dict = initializer_range SCREAMING_SNAKE_CASE_ : Optional[Any] = scale_attn_weights SCREAMING_SNAKE_CASE_ : List[Any] = use_cache SCREAMING_SNAKE_CASE_ : Any = scale_attn_by_inverse_layer_idx SCREAMING_SNAKE_CASE_ : str = reorder_and_upcast_attn SCREAMING_SNAKE_CASE_ : List[str] = bos_token_id SCREAMING_SNAKE_CASE_ : Any = eos_token_id super().__init__(bos_token_id=a__ , eos_token_id=a__ , **a__)
354
"""simple docstring""" UpperCAmelCase_ : Optional[int] = 8.3_1_4_4_5_9_8 def _A (__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 UpperCAmelCase_ : str = 300 UpperCAmelCase_ : str = 28 UpperCAmelCase_ : Any = rms_speed_of_molecule(temperature, molar_mass) print(f'''Vrms of Nitrogen gas at 300 K is {vrms} m/s''')
318
0
"""simple docstring""" import json from typing import TYPE_CHECKING, List, Optional, Tuple from tokenizers import pre_tokenizers from ...tokenization_utils_base import BatchEncoding from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_gpta import GPTaTokenizer if TYPE_CHECKING: from transformers.pipelines.conversational import Conversation UpperCAmelCase_ : int = logging.get_logger(__name__) UpperCAmelCase_ : Tuple = {"""vocab_file""": """vocab.json""", """merges_file""": """merges.txt""", """tokenizer_file""": """tokenizer.json"""} UpperCAmelCase_ : Any = { """vocab_file""": { """gpt2""": """https://huggingface.co/gpt2/resolve/main/vocab.json""", """gpt2-medium""": """https://huggingface.co/gpt2-medium/resolve/main/vocab.json""", """gpt2-large""": """https://huggingface.co/gpt2-large/resolve/main/vocab.json""", """gpt2-xl""": """https://huggingface.co/gpt2-xl/resolve/main/vocab.json""", """distilgpt2""": """https://huggingface.co/distilgpt2/resolve/main/vocab.json""", }, """merges_file""": { """gpt2""": """https://huggingface.co/gpt2/resolve/main/merges.txt""", """gpt2-medium""": """https://huggingface.co/gpt2-medium/resolve/main/merges.txt""", """gpt2-large""": """https://huggingface.co/gpt2-large/resolve/main/merges.txt""", """gpt2-xl""": """https://huggingface.co/gpt2-xl/resolve/main/merges.txt""", """distilgpt2""": """https://huggingface.co/distilgpt2/resolve/main/merges.txt""", }, """tokenizer_file""": { """gpt2""": """https://huggingface.co/gpt2/resolve/main/tokenizer.json""", """gpt2-medium""": """https://huggingface.co/gpt2-medium/resolve/main/tokenizer.json""", """gpt2-large""": """https://huggingface.co/gpt2-large/resolve/main/tokenizer.json""", """gpt2-xl""": """https://huggingface.co/gpt2-xl/resolve/main/tokenizer.json""", """distilgpt2""": """https://huggingface.co/distilgpt2/resolve/main/tokenizer.json""", }, } UpperCAmelCase_ : List[Any] = { """gpt2""": 1024, """gpt2-medium""": 1024, """gpt2-large""": 1024, """gpt2-xl""": 1024, """distilgpt2""": 1024, } class lowerCAmelCase__ ( UpperCamelCase__ ): '''simple docstring''' __UpperCamelCase = VOCAB_FILES_NAMES __UpperCamelCase = PRETRAINED_VOCAB_FILES_MAP __UpperCamelCase = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES __UpperCamelCase = ['''input_ids''', '''attention_mask'''] __UpperCamelCase = GPTaTokenizer def __init__( self : Any , lowercase_ : Tuple=None , lowercase_ : Optional[int]=None , lowercase_ : Optional[int]=None , lowercase_ : Dict="<|endoftext|>" , lowercase_ : Tuple="<|endoftext|>" , lowercase_ : List[str]="<|endoftext|>" , lowercase_ : List[Any]=False , **lowercase_ : str , ): '''simple docstring''' super().__init__( UpperCamelCase_ , UpperCamelCase_ , tokenizer_file=UpperCamelCase_ , unk_token=UpperCamelCase_ , bos_token=UpperCamelCase_ , eos_token=UpperCamelCase_ , add_prefix_space=UpperCamelCase_ , **UpperCamelCase_ , ) SCREAMING_SNAKE_CASE_ : Any = kwargs.pop('''add_bos_token''' , UpperCamelCase_) SCREAMING_SNAKE_CASE_ : List[Any] = json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__()) if pre_tok_state.get('''add_prefix_space''' , UpperCamelCase_) != add_prefix_space: SCREAMING_SNAKE_CASE_ : List[str] = getattr(UpperCamelCase_ , pre_tok_state.pop('''type''')) SCREAMING_SNAKE_CASE_ : Any = add_prefix_space SCREAMING_SNAKE_CASE_ : Any = pre_tok_class(**UpperCamelCase_) SCREAMING_SNAKE_CASE_ : Tuple = add_prefix_space def _SCREAMING_SNAKE_CASE ( self : Dict , *lowercase_ : int , **lowercase_ : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = kwargs.get('''is_split_into_words''' , UpperCamelCase_) assert self.add_prefix_space or not is_split_into_words, ( F'You need to instantiate {self.__class__.__name__} with add_prefix_space=True ' "to use it with pretokenized inputs." ) return super()._batch_encode_plus(*UpperCamelCase_ , **UpperCamelCase_) def _SCREAMING_SNAKE_CASE ( self : Tuple , *lowercase_ : int , **lowercase_ : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = kwargs.get('''is_split_into_words''' , UpperCamelCase_) assert self.add_prefix_space or not is_split_into_words, ( F'You need to instantiate {self.__class__.__name__} with add_prefix_space=True ' "to use it with pretokenized inputs." ) return super()._encode_plus(*UpperCamelCase_ , **UpperCamelCase_) def _SCREAMING_SNAKE_CASE ( self : Optional[int] , lowercase_ : str , lowercase_ : Optional[str] = None): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = self._tokenizer.model.save(UpperCamelCase_ , name=UpperCamelCase_) return tuple(UpperCamelCase_) def _SCREAMING_SNAKE_CASE ( self : int , lowercase_ : "Conversation"): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = [] for is_user, text in conversation.iter_texts(): input_ids.extend(self.encode(UpperCamelCase_ , add_special_tokens=UpperCamelCase_) + [self.eos_token_id]) if len(UpperCamelCase_) > self.model_max_length: SCREAMING_SNAKE_CASE_ : Optional[int] = input_ids[-self.model_max_length :] return input_ids
355
"""simple docstring""" import json import multiprocessing import os import re from collections import defaultdict import torch from accelerate import Accelerator from accelerate.utils import set_seed from arguments import HumanEvalArguments from datasets import load_dataset, load_metric from torch.utils.data import IterableDataset from torch.utils.data.dataloader import DataLoader from tqdm import tqdm import transformers from transformers import AutoModelForCausalLM, AutoTokenizer, HfArgumentParser, StoppingCriteria, StoppingCriteriaList UpperCAmelCase_ : Union[str, Any] = ["""\nclass""", """\ndef""", """\n#""", """\n@""", """\nprint""", """\nif"""] class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def __init__( self : List[Any] , lowercase_ : Tuple , lowercase_ : Optional[int] , lowercase_ : int=None , lowercase_ : Dict=1): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = tokenizer SCREAMING_SNAKE_CASE_ : Optional[int] = dataset SCREAMING_SNAKE_CASE_ : Optional[Any] = len(lowercase_) if n_tasks is None else n_tasks SCREAMING_SNAKE_CASE_ : Optional[int] = n_copies def __iter__( self : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = [] for task in range(self.n_tasks): # without strip, the model generate commented codes ... prompts.append(self.tokenizer.eos_token + self.dataset[task]['''prompt'''].strip()) SCREAMING_SNAKE_CASE_ : Optional[Any] = self.tokenizer(lowercase_ , padding=lowercase_ , return_tensors='''pt''') for task in range(self.n_tasks): for _ in range(self.n_copies): yield { "ids": outputs.input_ids[task], "task_id": task, "input_len": outputs.attention_mask[task].sum(), } class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def __init__( self : int , lowercase_ : Dict , lowercase_ : Optional[Any] , lowercase_ : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = start_length SCREAMING_SNAKE_CASE_ : List[Any] = eof_strings SCREAMING_SNAKE_CASE_ : List[Any] = tokenizer def __call__( self : Optional[int] , lowercase_ : Any , lowercase_ : int , **lowercase_ : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = self.tokenizer.batch_decode(input_ids[:, self.start_length :]) SCREAMING_SNAKE_CASE_ : Tuple = [] for decoded_generation in decoded_generations: done.append(any(stop_string in decoded_generation for stop_string in self.eof_strings)) return all(lowercase_) def _A (__a ) -> Union[str, Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Dict = re.split('''(%s)''' % '''|'''.join(__a ) , __a ) # last string should be "" return "".join(string_list[:-2] ) def _A (__a , __a , __a , __a , __a , __a=20 , **__a ) -> List[str]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Tuple = defaultdict(__a ) # dict of list of generated tokens for step, batch in tqdm(enumerate(__a ) ): with torch.no_grad(): SCREAMING_SNAKE_CASE_ : Optional[int] = batch['''ids'''].shape[-1] SCREAMING_SNAKE_CASE_ : Tuple = accelerator.unwrap_model(__a ).generate( input_ids=batch['''ids'''][:, : batch['''input_len''']] , num_return_sequences=__a , **__a ) # each task is generated batch_size times SCREAMING_SNAKE_CASE_ : List[Any] = batch['''task_id'''].repeat(__a ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = accelerator.pad_across_processes( __a , dim=1 , pad_index=tokenizer.pad_token_id ) SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Union[str, Any] = accelerator.gather((generated_tokens, generated_tasks) ) SCREAMING_SNAKE_CASE_ : int = generated_tokens.cpu().numpy() SCREAMING_SNAKE_CASE_ : Optional[Any] = generated_tasks.cpu().numpy() for task, generated_tokens in zip(__a , __a ): gen_token_dict[task].append(__a ) SCREAMING_SNAKE_CASE_ : int = [[] for _ in range(__a )] for task, generated_tokens in gen_token_dict.items(): for s in generated_tokens: SCREAMING_SNAKE_CASE_ : Optional[int] = tokenizer.decode(__a , skip_special_tokens=__a , clean_up_tokenization_spaces=__a ) code_gens[task].append(remove_last_block(__a ) ) return code_gens def _A () -> Optional[int]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Union[str, Any] = HfArgumentParser(__a ) SCREAMING_SNAKE_CASE_ : List[Any] = parser.parse_args() transformers.logging.set_verbosity_error() # enables code execution in code_eval metric SCREAMING_SNAKE_CASE_ : Any = args.HF_ALLOW_CODE_EVAL # make sure tokenizer plays nice with multiprocessing SCREAMING_SNAKE_CASE_ : str = '''false''' if args.num_workers is None: SCREAMING_SNAKE_CASE_ : Optional[Any] = multiprocessing.cpu_count() # Use dataset load to feed to accelerate SCREAMING_SNAKE_CASE_ : Tuple = Accelerator() set_seed(args.seed , device_specific=__a ) # Load model and tokenizer SCREAMING_SNAKE_CASE_ : Dict = AutoTokenizer.from_pretrained(args.model_ckpt ) SCREAMING_SNAKE_CASE_ : Dict = tokenizer.eos_token SCREAMING_SNAKE_CASE_ : Optional[int] = AutoModelForCausalLM.from_pretrained(args.model_ckpt ) # Generation settings SCREAMING_SNAKE_CASE_ : List[str] = { '''do_sample''': args.do_sample, '''temperature''': args.temperature, '''max_new_tokens''': args.max_new_tokens, '''top_p''': args.top_p, '''top_k''': args.top_k, '''stopping_criteria''': StoppingCriteriaList([EndOfFunctionCriteria(0 , __a , __a )] ), } # Load evaluation dataset and metric SCREAMING_SNAKE_CASE_ : Optional[int] = load_dataset('''openai_humaneval''' ) SCREAMING_SNAKE_CASE_ : str = load_metric('''code_eval''' ) SCREAMING_SNAKE_CASE_ : int = args.num_tasks if args.num_tasks is not None else len(human_eval['''test'''] ) SCREAMING_SNAKE_CASE_ : List[str] = args.n_samples // args.batch_size SCREAMING_SNAKE_CASE_ : Union[str, Any] = TokenizedDataset(__a , human_eval['''test'''] , n_copies=__a , n_tasks=__a ) # do not confuse args.batch_size, which is actually the num_return_sequences SCREAMING_SNAKE_CASE_ : Optional[int] = DataLoader(__a , batch_size=1 ) # Run a quick test to see if code evaluation is enabled try: SCREAMING_SNAKE_CASE_ : Any = code_eval_metric.compute(references=[''''''] , predictions=[['''''']] ) except ValueError as exception: print( '''Code evaluation not enabled. Read the warning below carefully and then use `--HF_ALLOW_CODE_EVAL="1"`''' ''' flag to enable code evaluation.''' ) raise exception SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : int = accelerator.prepare(__a , __a ) SCREAMING_SNAKE_CASE_ : List[Any] = complete_code( __a , __a , __a , __a , n_tasks=__a , batch_size=args.batch_size , **__a , ) if accelerator.is_main_process: SCREAMING_SNAKE_CASE_ : int = [] for task in tqdm(range(__a ) ): SCREAMING_SNAKE_CASE_ : Tuple = human_eval['''test'''][task]['''test'''] SCREAMING_SNAKE_CASE_ : Tuple = f'check({human_eval["test"][task]["entry_point"]})' references.append('''\n''' + test_func + '''\n''' + entry_point ) # Evaluate completions with "code_eval" metric SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Dict = code_eval_metric.compute( references=__a , predictions=__a , num_workers=args.num_workers ) print(f'Results: {pass_at_k}' ) # Save results to json file with open(args.output_file , '''w''' ) as fp: json.dump(__a , __a ) # For some reason the folliwng seems to be necessary sometimes for code_eval to work nice with multiprocessing # https://stackoverflow.com/questions/60804599/python-multiprocessing-keeps-spawning-the-whole-script if __name__ == "__main__": main()
318
0
"""simple docstring""" from math import pow def _A (__a , __a , __a , __a , __a , ) -> List[Any]: """simple docstring""" if current_sum == needed_sum: # If the sum of the powers is equal to needed_sum, then we have a solution. solutions_count += 1 return current_sum, solutions_count SCREAMING_SNAKE_CASE_ : Tuple = int(pow(lowerCamelCase_ , lowerCamelCase_ ) ) if current_sum + i_to_n <= needed_sum: # If the sum of the powers is less than needed_sum, then continue adding powers. current_sum += i_to_n SCREAMING_SNAKE_CASE_ : int = backtrack( lowerCamelCase_ , lowerCamelCase_ , current_number + 1 , lowerCamelCase_ , lowerCamelCase_ ) current_sum -= i_to_n if i_to_n < needed_sum: # If the power of i is less than needed_sum, then try with the next power. SCREAMING_SNAKE_CASE_ : Any = backtrack( lowerCamelCase_ , lowerCamelCase_ , current_number + 1 , lowerCamelCase_ , lowerCamelCase_ ) return current_sum, solutions_count def _A (__a , __a ) -> int: """simple docstring""" if not (1 <= needed_sum <= 10_00 and 2 <= power <= 10): raise ValueError( '''Invalid input\n''' '''needed_sum must be between 1 and 1000, power between 2 and 10.''' ) return backtrack(lowerCamelCase_ , lowerCamelCase_ , 1 , 0 , 0 )[1] # Return the solutions_count if __name__ == "__main__": import doctest doctest.testmod()
356
"""simple docstring""" from ...processing_utils import ProcessorMixin class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = ["image_processor", "feature_extractor"] __UpperCamelCase = "TvltImageProcessor" __UpperCamelCase = "TvltFeatureExtractor" def __init__( self : int , lowercase_ : Optional[Any] , lowercase_ : Optional[Any]): '''simple docstring''' super().__init__(image_processor=lowercase_ , feature_extractor=lowercase_) SCREAMING_SNAKE_CASE_ : Union[str, Any] = image_processor SCREAMING_SNAKE_CASE_ : Optional[Any] = feature_extractor def __call__( self : Any , lowercase_ : str=None , lowercase_ : Optional[Any]=None , lowercase_ : Optional[Any]=None , lowercase_ : str=None , lowercase_ : int=False , lowercase_ : Union[str, Any]=False , *lowercase_ : List[Any] , **lowercase_ : List[str] , ): '''simple docstring''' if images is None and audio is None: raise ValueError('''You need to specify either an `images` or `audio` input to process.''') SCREAMING_SNAKE_CASE_ : Any = None if images is not None: SCREAMING_SNAKE_CASE_ : Tuple = self.image_processor(lowercase_ , mask_pixel=lowercase_ , *lowercase_ , **lowercase_) if images_mixed is not None: SCREAMING_SNAKE_CASE_ : Optional[int] = self.image_processor(lowercase_ , is_mixed=lowercase_ , *lowercase_ , **lowercase_) if audio is not None: SCREAMING_SNAKE_CASE_ : Any = self.feature_extractor( lowercase_ , *lowercase_ , sampling_rate=lowercase_ , mask_audio=lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : List[Any] = {} if audio is not None: output_dict.update(lowercase_) if images is not None: output_dict.update(lowercase_) if images_mixed_dict is not None: output_dict.update(lowercase_) return output_dict @property def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = self.image_processor.model_input_names SCREAMING_SNAKE_CASE_ : Dict = self.feature_extractor.model_input_names return list(dict.fromkeys(image_processor_input_names + feature_extractor_input_names))
318
0
"""simple docstring""" import warnings from ...utils import logging from .image_processing_poolformer import PoolFormerImageProcessor UpperCAmelCase_ : Optional[Any] = logging.get_logger(__name__) class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def __init__( self : List[Any] , *lowercase_ : Any , **lowercase_ : Tuple): '''simple docstring''' warnings.warn( '''The class PoolFormerFeatureExtractor is deprecated and will be removed in version 5 of Transformers.''' ''' Please use PoolFormerImageProcessor instead.''' , _A , ) super().__init__(*_A , **_A)
357
"""simple docstring""" from ...processing_utils import ProcessorMixin class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = "SpeechT5FeatureExtractor" __UpperCamelCase = "SpeechT5Tokenizer" def __init__( self : Any , lowercase_ : Dict , lowercase_ : Optional[Any]): '''simple docstring''' super().__init__(lowercase_ , lowercase_) def __call__( self : List[Any] , *lowercase_ : List[Any] , **lowercase_ : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[str] = kwargs.pop('''audio''' , lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = kwargs.pop('''text''' , lowercase_) SCREAMING_SNAKE_CASE_ : Any = kwargs.pop('''text_target''' , lowercase_) SCREAMING_SNAKE_CASE_ : Dict = kwargs.pop('''audio_target''' , lowercase_) SCREAMING_SNAKE_CASE_ : List[Any] = kwargs.pop('''sampling_rate''' , lowercase_) if audio is not None and text is not None: raise ValueError( '''Cannot process both `audio` and `text` inputs. Did you mean `audio_target` or `text_target`?''') if audio_target is not None and text_target is not None: raise ValueError( '''Cannot process both `audio_target` and `text_target` inputs. Did you mean `audio` or `text`?''') if audio is None and audio_target is None and text is None and text_target is None: raise ValueError( '''You need to specify either an `audio`, `audio_target`, `text`, or `text_target` input to process.''') if audio is not None: SCREAMING_SNAKE_CASE_ : Any = self.feature_extractor(lowercase_ , *lowercase_ , sampling_rate=lowercase_ , **lowercase_) elif text is not None: SCREAMING_SNAKE_CASE_ : Dict = self.tokenizer(lowercase_ , **lowercase_) else: SCREAMING_SNAKE_CASE_ : Any = None if audio_target is not None: SCREAMING_SNAKE_CASE_ : List[Any] = self.feature_extractor(audio_target=lowercase_ , *lowercase_ , sampling_rate=lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = targets['''input_values'''] elif text_target is not None: SCREAMING_SNAKE_CASE_ : int = self.tokenizer(lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : List[Any] = targets['''input_ids'''] else: SCREAMING_SNAKE_CASE_ : int = None if inputs is None: return targets if targets is not None: SCREAMING_SNAKE_CASE_ : Union[str, Any] = labels SCREAMING_SNAKE_CASE_ : Optional[Any] = targets.get('''attention_mask''') if decoder_attention_mask is not None: SCREAMING_SNAKE_CASE_ : Any = decoder_attention_mask return inputs def _SCREAMING_SNAKE_CASE ( self : Tuple , *lowercase_ : Tuple , **lowercase_ : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = kwargs.pop('''input_values''' , lowercase_) SCREAMING_SNAKE_CASE_ : int = kwargs.pop('''input_ids''' , lowercase_) SCREAMING_SNAKE_CASE_ : Dict = kwargs.pop('''labels''' , lowercase_) if input_values is not None and input_ids is not None: raise ValueError('''Cannot process both `input_values` and `input_ids` inputs.''') if input_values is None and input_ids is None and labels is None: raise ValueError( '''You need to specify either an `input_values`, `input_ids`, or `labels` input to be padded.''') if input_values is not None: SCREAMING_SNAKE_CASE_ : Any = self.feature_extractor.pad(lowercase_ , *lowercase_ , **lowercase_) elif input_ids is not None: SCREAMING_SNAKE_CASE_ : Tuple = self.tokenizer.pad(lowercase_ , **lowercase_) else: SCREAMING_SNAKE_CASE_ : List[Any] = None if labels is not None: if "input_ids" in labels or (isinstance(lowercase_ , lowercase_) and "input_ids" in labels[0]): SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.tokenizer.pad(lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : Dict = targets['''input_ids'''] else: SCREAMING_SNAKE_CASE_ : Dict = self.feature_extractor.feature_size SCREAMING_SNAKE_CASE_ : Optional[int] = self.feature_extractor.num_mel_bins SCREAMING_SNAKE_CASE_ : str = self.feature_extractor.pad(lowercase_ , *lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : str = feature_size_hack SCREAMING_SNAKE_CASE_ : Dict = targets['''input_values'''] else: SCREAMING_SNAKE_CASE_ : List[Any] = None if inputs is None: return targets if targets is not None: SCREAMING_SNAKE_CASE_ : Dict = labels SCREAMING_SNAKE_CASE_ : List[str] = targets.get('''attention_mask''') if decoder_attention_mask is not None: SCREAMING_SNAKE_CASE_ : Optional[Any] = decoder_attention_mask return inputs def _SCREAMING_SNAKE_CASE ( self : Optional[Any] , *lowercase_ : Optional[int] , **lowercase_ : Tuple): '''simple docstring''' return self.tokenizer.batch_decode(*lowercase_ , **lowercase_) def _SCREAMING_SNAKE_CASE ( self : List[Any] , *lowercase_ : Dict , **lowercase_ : List[Any]): '''simple docstring''' return self.tokenizer.decode(*lowercase_ , **lowercase_)
318
0
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_torch_available UpperCAmelCase_ : str = { 'configuration_gpt_neo': ['GPT_NEO_PRETRAINED_CONFIG_ARCHIVE_MAP', 'GPTNeoConfig', 'GPTNeoOnnxConfig'], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase_ : List[str] = [ 'GPT_NEO_PRETRAINED_MODEL_ARCHIVE_LIST', 'GPTNeoForCausalLM', 'GPTNeoForQuestionAnswering', 'GPTNeoForSequenceClassification', 'GPTNeoForTokenClassification', 'GPTNeoModel', 'GPTNeoPreTrainedModel', 'load_tf_weights_in_gpt_neo', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase_ : int = [ 'FlaxGPTNeoForCausalLM', 'FlaxGPTNeoModel', 'FlaxGPTNeoPreTrainedModel', ] if TYPE_CHECKING: from .configuration_gpt_neo import GPT_NEO_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTNeoConfig, GPTNeoOnnxConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_gpt_neo import ( GPT_NEO_PRETRAINED_MODEL_ARCHIVE_LIST, GPTNeoForCausalLM, GPTNeoForQuestionAnswering, GPTNeoForSequenceClassification, GPTNeoForTokenClassification, GPTNeoModel, GPTNeoPreTrainedModel, load_tf_weights_in_gpt_neo, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_gpt_neo import FlaxGPTNeoForCausalLM, FlaxGPTNeoModel, FlaxGPTNeoPreTrainedModel else: import sys UpperCAmelCase_ : Tuple = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
358
"""simple docstring""" import os from typing import BinaryIO, Optional, Union import numpy as np import pyarrow.parquet as pq from .. import Audio, Dataset, Features, Image, NamedSplit, Value, config from ..features.features import FeatureType, _visit from ..formatting import query_table from ..packaged_modules import _PACKAGED_DATASETS_MODULES from ..packaged_modules.parquet.parquet import Parquet from ..utils import logging from ..utils.typing import NestedDataStructureLike, PathLike from .abc import AbstractDatasetReader def _A (__a ) -> Optional[int]: """simple docstring""" SCREAMING_SNAKE_CASE_ : List[str] = np.inf def set_batch_size(__a ) -> None: nonlocal batch_size if isinstance(__a , __a ): SCREAMING_SNAKE_CASE_ : Tuple = min(__a , config.PARQUET_ROW_GROUP_SIZE_FOR_IMAGE_DATASETS ) elif isinstance(__a , __a ): SCREAMING_SNAKE_CASE_ : int = min(__a , config.PARQUET_ROW_GROUP_SIZE_FOR_AUDIO_DATASETS ) elif isinstance(__a , __a ) and feature.dtype == "binary": SCREAMING_SNAKE_CASE_ : Union[str, Any] = min(__a , config.PARQUET_ROW_GROUP_SIZE_FOR_BINARY_DATASETS ) _visit(__a , __a ) return None if batch_size is np.inf else batch_size class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def __init__( self : Any , lowercase_ : NestedDataStructureLike[PathLike] , lowercase_ : Optional[NamedSplit] = None , lowercase_ : Optional[Features] = None , lowercase_ : str = None , lowercase_ : bool = False , lowercase_ : bool = False , lowercase_ : Optional[int] = None , **lowercase_ : Optional[int] , ): '''simple docstring''' super().__init__( lowercase_ , split=lowercase_ , features=lowercase_ , cache_dir=lowercase_ , keep_in_memory=lowercase_ , streaming=lowercase_ , num_proc=lowercase_ , **lowercase_ , ) SCREAMING_SNAKE_CASE_ : Any = path_or_paths if isinstance(lowercase_ , lowercase_) else {self.split: path_or_paths} SCREAMING_SNAKE_CASE_ : Any = _PACKAGED_DATASETS_MODULES['''parquet'''][1] SCREAMING_SNAKE_CASE_ : Union[str, Any] = Parquet( cache_dir=lowercase_ , data_files=lowercase_ , features=lowercase_ , hash=lowercase_ , **lowercase_ , ) def _SCREAMING_SNAKE_CASE ( self : Tuple): '''simple docstring''' if self.streaming: SCREAMING_SNAKE_CASE_ : str = self.builder.as_streaming_dataset(split=self.split) # Build regular (map-style) dataset else: SCREAMING_SNAKE_CASE_ : Optional[Any] = None SCREAMING_SNAKE_CASE_ : Optional[int] = None SCREAMING_SNAKE_CASE_ : Tuple = None SCREAMING_SNAKE_CASE_ : Dict = None self.builder.download_and_prepare( download_config=lowercase_ , download_mode=lowercase_ , verification_mode=lowercase_ , base_path=lowercase_ , num_proc=self.num_proc , ) SCREAMING_SNAKE_CASE_ : Any = self.builder.as_dataset( split=self.split , verification_mode=lowercase_ , in_memory=self.keep_in_memory) return dataset class lowerCAmelCase__ : '''simple docstring''' def __init__( self : Tuple , lowercase_ : Dataset , lowercase_ : Union[PathLike, BinaryIO] , lowercase_ : Optional[int] = None , **lowercase_ : Dict , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = dataset SCREAMING_SNAKE_CASE_ : Dict = path_or_buf SCREAMING_SNAKE_CASE_ : List[Any] = batch_size or get_writer_batch_size(dataset.features) SCREAMING_SNAKE_CASE_ : Any = parquet_writer_kwargs def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[str] = self.batch_size if self.batch_size else config.DEFAULT_MAX_BATCH_SIZE if isinstance(self.path_or_buf , (str, bytes, os.PathLike)): with open(self.path_or_buf , '''wb+''') as buffer: SCREAMING_SNAKE_CASE_ : Optional[Any] = self._write(file_obj=lowercase_ , batch_size=lowercase_ , **self.parquet_writer_kwargs) else: SCREAMING_SNAKE_CASE_ : str = self._write(file_obj=self.path_or_buf , batch_size=lowercase_ , **self.parquet_writer_kwargs) return written def _SCREAMING_SNAKE_CASE ( self : Tuple , lowercase_ : BinaryIO , lowercase_ : int , **lowercase_ : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = 0 SCREAMING_SNAKE_CASE_ : Optional[int] = parquet_writer_kwargs.pop('''path_or_buf''' , lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = self.dataset.features.arrow_schema SCREAMING_SNAKE_CASE_ : Tuple = pq.ParquetWriter(lowercase_ , schema=lowercase_ , **lowercase_) for offset in logging.tqdm( range(0 , len(self.dataset) , lowercase_) , unit='''ba''' , disable=not logging.is_progress_bar_enabled() , desc='''Creating parquet from Arrow format''' , ): SCREAMING_SNAKE_CASE_ : List[Any] = query_table( table=self.dataset._data , key=slice(lowercase_ , offset + batch_size) , indices=self.dataset._indices if self.dataset._indices is not None else None , ) writer.write_table(lowercase_) written += batch.nbytes writer.close() return written
318
0
"""simple docstring""" import unittest from transformers import AlbertConfig, is_torch_available from transformers.models.auto import get_values from transformers.testing_utils import require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( MODEL_FOR_PRETRAINING_MAPPING, AlbertForMaskedLM, AlbertForMultipleChoice, AlbertForPreTraining, AlbertForQuestionAnswering, AlbertForSequenceClassification, AlbertForTokenClassification, AlbertModel, ) from transformers.models.albert.modeling_albert import ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST class lowerCAmelCase__ : '''simple docstring''' def __init__( self : List[str] , lowercase_ : Tuple , lowercase_ : Any=13 , lowercase_ : Optional[Any]=7 , lowercase_ : Tuple=True , lowercase_ : List[Any]=True , lowercase_ : Tuple=True , lowercase_ : Optional[int]=True , lowercase_ : Any=99 , lowercase_ : Optional[int]=16 , lowercase_ : Dict=36 , lowercase_ : Dict=6 , lowercase_ : Any=6 , lowercase_ : List[str]=6 , lowercase_ : Optional[Any]=37 , lowercase_ : Dict="gelu" , lowercase_ : Optional[Any]=0.1 , lowercase_ : Optional[Any]=0.1 , lowercase_ : str=512 , lowercase_ : Dict=16 , lowercase_ : Optional[Any]=2 , lowercase_ : int=0.02 , lowercase_ : Any=3 , lowercase_ : List[str]=4 , lowercase_ : Dict=None , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = parent SCREAMING_SNAKE_CASE_ : List[Any] = batch_size SCREAMING_SNAKE_CASE_ : Optional[int] = seq_length SCREAMING_SNAKE_CASE_ : List[str] = is_training SCREAMING_SNAKE_CASE_ : Optional[int] = use_input_mask SCREAMING_SNAKE_CASE_ : str = use_token_type_ids SCREAMING_SNAKE_CASE_ : Union[str, Any] = use_labels SCREAMING_SNAKE_CASE_ : int = vocab_size SCREAMING_SNAKE_CASE_ : Union[str, Any] = embedding_size SCREAMING_SNAKE_CASE_ : Union[str, Any] = hidden_size SCREAMING_SNAKE_CASE_ : List[str] = num_hidden_layers SCREAMING_SNAKE_CASE_ : Optional[int] = num_hidden_groups SCREAMING_SNAKE_CASE_ : Optional[Any] = num_attention_heads SCREAMING_SNAKE_CASE_ : Tuple = intermediate_size SCREAMING_SNAKE_CASE_ : str = hidden_act SCREAMING_SNAKE_CASE_ : str = hidden_dropout_prob SCREAMING_SNAKE_CASE_ : int = attention_probs_dropout_prob SCREAMING_SNAKE_CASE_ : Optional[Any] = max_position_embeddings SCREAMING_SNAKE_CASE_ : int = type_vocab_size SCREAMING_SNAKE_CASE_ : Optional[int] = type_sequence_label_size SCREAMING_SNAKE_CASE_ : str = initializer_range SCREAMING_SNAKE_CASE_ : List[Any] = num_labels SCREAMING_SNAKE_CASE_ : int = num_choices SCREAMING_SNAKE_CASE_ : List[Any] = scope def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size) SCREAMING_SNAKE_CASE_ : Dict = None if self.use_input_mask: SCREAMING_SNAKE_CASE_ : List[str] = random_attention_mask([self.batch_size, self.seq_length]) SCREAMING_SNAKE_CASE_ : List[str] = None if self.use_token_type_ids: SCREAMING_SNAKE_CASE_ : Optional[Any] = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size) SCREAMING_SNAKE_CASE_ : Optional[int] = None SCREAMING_SNAKE_CASE_ : List[str] = None SCREAMING_SNAKE_CASE_ : List[str] = None if self.use_labels: SCREAMING_SNAKE_CASE_ : List[str] = ids_tensor([self.batch_size] , self.type_sequence_label_size) SCREAMING_SNAKE_CASE_ : Dict = ids_tensor([self.batch_size, self.seq_length] , self.num_labels) SCREAMING_SNAKE_CASE_ : Union[str, Any] = ids_tensor([self.batch_size] , self.num_choices) SCREAMING_SNAKE_CASE_ : str = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' return AlbertConfig( 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 , num_hidden_groups=self.num_hidden_groups , ) def _SCREAMING_SNAKE_CASE ( self : int , lowercase_ : Tuple , lowercase_ : Any , lowercase_ : Any , lowercase_ : List[Any] , lowercase_ : Optional[int] , lowercase_ : Union[str, Any] , lowercase_ : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = AlbertModel(config=A__) model.to(A__) model.eval() SCREAMING_SNAKE_CASE_ : Tuple = model(A__ , attention_mask=A__ , token_type_ids=A__) SCREAMING_SNAKE_CASE_ : str = model(A__ , token_type_ids=A__) SCREAMING_SNAKE_CASE_ : Any = model(A__) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size)) self.parent.assertEqual(result.pooler_output.shape , (self.batch_size, self.hidden_size)) def _SCREAMING_SNAKE_CASE ( self : Optional[Any] , lowercase_ : Dict , lowercase_ : Union[str, Any] , lowercase_ : Union[str, Any] , lowercase_ : Tuple , lowercase_ : Any , lowercase_ : str , lowercase_ : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = AlbertForPreTraining(config=A__) model.to(A__) model.eval() SCREAMING_SNAKE_CASE_ : str = model( A__ , attention_mask=A__ , token_type_ids=A__ , labels=A__ , sentence_order_label=A__ , ) self.parent.assertEqual(result.prediction_logits.shape , (self.batch_size, self.seq_length, self.vocab_size)) self.parent.assertEqual(result.sop_logits.shape , (self.batch_size, config.num_labels)) def _SCREAMING_SNAKE_CASE ( self : Tuple , lowercase_ : Dict , lowercase_ : List[Any] , lowercase_ : Optional[Any] , lowercase_ : Optional[Any] , lowercase_ : List[str] , lowercase_ : Optional[int] , lowercase_ : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = AlbertForMaskedLM(config=A__) model.to(A__) model.eval() SCREAMING_SNAKE_CASE_ : Tuple = model(A__ , attention_mask=A__ , token_type_ids=A__ , labels=A__) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size)) def _SCREAMING_SNAKE_CASE ( self : List[str] , lowercase_ : Optional[int] , lowercase_ : Any , lowercase_ : List[str] , lowercase_ : List[str] , lowercase_ : List[Any] , lowercase_ : List[Any] , lowercase_ : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = AlbertForQuestionAnswering(config=A__) model.to(A__) model.eval() SCREAMING_SNAKE_CASE_ : Optional[int] = model( A__ , attention_mask=A__ , token_type_ids=A__ , start_positions=A__ , end_positions=A__ , ) 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 _SCREAMING_SNAKE_CASE ( self : Optional[int] , lowercase_ : str , lowercase_ : Union[str, Any] , lowercase_ : Union[str, Any] , lowercase_ : str , lowercase_ : str , lowercase_ : Union[str, Any] , lowercase_ : Any): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = self.num_labels SCREAMING_SNAKE_CASE_ : str = AlbertForSequenceClassification(A__) model.to(A__) model.eval() SCREAMING_SNAKE_CASE_ : int = model(A__ , attention_mask=A__ , token_type_ids=A__ , labels=A__) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels)) def _SCREAMING_SNAKE_CASE ( self : int , lowercase_ : Tuple , lowercase_ : Union[str, Any] , lowercase_ : str , lowercase_ : List[Any] , lowercase_ : List[str] , lowercase_ : List[Any] , lowercase_ : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = self.num_labels SCREAMING_SNAKE_CASE_ : int = AlbertForTokenClassification(config=A__) model.to(A__) model.eval() SCREAMING_SNAKE_CASE_ : Dict = model(A__ , attention_mask=A__ , token_type_ids=A__ , labels=A__) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels)) def _SCREAMING_SNAKE_CASE ( self : str , lowercase_ : List[Any] , lowercase_ : List[Any] , lowercase_ : Union[str, Any] , lowercase_ : Optional[Any] , lowercase_ : Optional[int] , lowercase_ : List[Any] , lowercase_ : Tuple): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = self.num_choices SCREAMING_SNAKE_CASE_ : Optional[Any] = AlbertForMultipleChoice(config=A__) model.to(A__) model.eval() SCREAMING_SNAKE_CASE_ : int = input_ids.unsqueeze(1).expand(-1 , self.num_choices , -1).contiguous() SCREAMING_SNAKE_CASE_ : int = token_type_ids.unsqueeze(1).expand(-1 , self.num_choices , -1).contiguous() SCREAMING_SNAKE_CASE_ : Union[str, Any] = input_mask.unsqueeze(1).expand(-1 , self.num_choices , -1).contiguous() SCREAMING_SNAKE_CASE_ : Dict = model( A__ , attention_mask=A__ , token_type_ids=A__ , labels=A__ , ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices)) def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = self.prepare_config_and_inputs() ( ( SCREAMING_SNAKE_CASE_ ) , ( SCREAMING_SNAKE_CASE_ ) , ( SCREAMING_SNAKE_CASE_ ) , ( SCREAMING_SNAKE_CASE_ ) , ( SCREAMING_SNAKE_CASE_ ) , ( SCREAMING_SNAKE_CASE_ ) , ( SCREAMING_SNAKE_CASE_ ) , ) : Tuple = config_and_inputs SCREAMING_SNAKE_CASE_ : Any = {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask} return config, inputs_dict @require_torch class lowerCAmelCase__ ( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , unittest.TestCase ): '''simple docstring''' __UpperCamelCase = ( ( AlbertModel, AlbertForPreTraining, AlbertForMaskedLM, AlbertForMultipleChoice, AlbertForSequenceClassification, AlbertForTokenClassification, AlbertForQuestionAnswering, ) if is_torch_available() else () ) __UpperCamelCase = ( { '''feature-extraction''': AlbertModel, '''fill-mask''': AlbertForMaskedLM, '''question-answering''': AlbertForQuestionAnswering, '''text-classification''': AlbertForSequenceClassification, '''token-classification''': AlbertForTokenClassification, '''zero-shot''': AlbertForSequenceClassification, } if is_torch_available() else {} ) __UpperCamelCase = True def _SCREAMING_SNAKE_CASE ( self : Optional[int] , lowercase_ : List[Any] , lowercase_ : Any , lowercase_ : List[str]=False): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = super()._prepare_for_class(A__ , A__ , return_labels=A__) if return_labels: if model_class in get_values(A__): SCREAMING_SNAKE_CASE_ : Optional[Any] = torch.zeros( (self.model_tester.batch_size, self.model_tester.seq_length) , dtype=torch.long , device=A__) SCREAMING_SNAKE_CASE_ : List[str] = torch.zeros( self.model_tester.batch_size , dtype=torch.long , device=A__) return inputs_dict def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = AlbertModelTester(self) SCREAMING_SNAKE_CASE_ : int = ConfigTester(self , config_class=A__ , hidden_size=37) def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' self.config_tester.run_common_tests() def _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*A__) def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_pretraining(*A__) def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*A__) def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_multiple_choice(*A__) def _SCREAMING_SNAKE_CASE ( self : Any): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_question_answering(*A__) def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_sequence_classification(*A__) def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = self.model_tester.prepare_config_and_inputs() for type in ["absolute", "relative_key", "relative_key_query"]: SCREAMING_SNAKE_CASE_ : Union[str, Any] = type self.model_tester.create_and_check_model(*A__) @slow def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' for model_name in ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: SCREAMING_SNAKE_CASE_ : Dict = AlbertModel.from_pretrained(A__) self.assertIsNotNone(A__) @require_torch class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' @slow def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[str] = AlbertModel.from_pretrained('''albert-base-v2''') SCREAMING_SNAKE_CASE_ : Tuple = torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]) SCREAMING_SNAKE_CASE_ : Optional[int] = torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]) with torch.no_grad(): SCREAMING_SNAKE_CASE_ : List[str] = model(A__ , attention_mask=A__)[0] SCREAMING_SNAKE_CASE_ : List[str] = torch.Size((1, 11, 768)) self.assertEqual(output.shape , A__) SCREAMING_SNAKE_CASE_ : Union[str, Any] = torch.tensor( [[[-0.65_13, 1.50_35, -0.27_66], [-0.65_15, 1.50_46, -0.27_80], [-0.65_12, 1.50_49, -0.27_84]]]) self.assertTrue(torch.allclose(output[:, 1:4, 1:4] , A__ , atol=1e-4))
359
"""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() UpperCAmelCase_ : str = logging.get_logger(__name__) UpperCAmelCase_ : Optional[Any] = ["""model.decoder.embed_positions.weights"""] def _A (__a ) -> Dict: """simple docstring""" if "emb" in name: SCREAMING_SNAKE_CASE_ : Optional[int] = name.replace('''emb''' , '''model.decoder.embed_tokens''' ) if "transformer" in name: SCREAMING_SNAKE_CASE_ : Tuple = name.replace('''transformer''' , '''model.decoder''' ) if "cross_attention" in name: SCREAMING_SNAKE_CASE_ : str = name.replace('''cross_attention''' , '''encoder_attn''' ) if "linear1" in name: SCREAMING_SNAKE_CASE_ : Optional[int] = name.replace('''linear1''' , '''fc1''' ) if "linear2" in name: SCREAMING_SNAKE_CASE_ : str = name.replace('''linear2''' , '''fc2''' ) if "norm1" in name: SCREAMING_SNAKE_CASE_ : Any = name.replace('''norm1''' , '''self_attn_layer_norm''' ) if "norm_cross" in name: SCREAMING_SNAKE_CASE_ : List[str] = name.replace('''norm_cross''' , '''encoder_attn_layer_norm''' ) if "norm2" in name: SCREAMING_SNAKE_CASE_ : Tuple = name.replace('''norm2''' , '''final_layer_norm''' ) if "out_norm" in name: SCREAMING_SNAKE_CASE_ : List[str] = name.replace('''out_norm''' , '''model.decoder.layer_norm''' ) if "linears" in name: SCREAMING_SNAKE_CASE_ : Dict = name.replace('''linears''' , '''lm_heads''' ) if "condition_provider.conditioners.description.output_proj" in name: SCREAMING_SNAKE_CASE_ : List[str] = name.replace('''condition_provider.conditioners.description.output_proj''' , '''enc_to_dec_proj''' ) return name def _A (__a , __a ) -> Tuple[Dict, Dict]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Union[str, Any] = list(state_dict.keys() ) SCREAMING_SNAKE_CASE_ : int = {} for key in keys: SCREAMING_SNAKE_CASE_ : int = state_dict.pop(__a ) SCREAMING_SNAKE_CASE_ : int = rename_keys(__a ) if "in_proj_weight" in key: # split fused qkv proj SCREAMING_SNAKE_CASE_ : List[str] = val[:hidden_size, :] SCREAMING_SNAKE_CASE_ : List[str] = val[hidden_size : 2 * hidden_size, :] SCREAMING_SNAKE_CASE_ : Optional[Any] = val[-hidden_size:, :] elif "enc_to_dec_proj" in key: SCREAMING_SNAKE_CASE_ : int = val else: SCREAMING_SNAKE_CASE_ : Any = val return state_dict, enc_dec_proj_state_dict def _A (__a ) -> MusicgenDecoderConfig: """simple docstring""" if checkpoint == "small": # default config values SCREAMING_SNAKE_CASE_ : Optional[int] = 10_24 SCREAMING_SNAKE_CASE_ : Tuple = 24 SCREAMING_SNAKE_CASE_ : Optional[Any] = 16 elif checkpoint == "medium": SCREAMING_SNAKE_CASE_ : List[str] = 15_36 SCREAMING_SNAKE_CASE_ : Optional[int] = 48 SCREAMING_SNAKE_CASE_ : Optional[int] = 24 elif checkpoint == "large": SCREAMING_SNAKE_CASE_ : Optional[Any] = 20_48 SCREAMING_SNAKE_CASE_ : Optional[int] = 48 SCREAMING_SNAKE_CASE_ : int = 32 else: raise ValueError(f'Checkpoint should be one of `[\'small\', \'medium\', \'large\']`, got {checkpoint}.' ) SCREAMING_SNAKE_CASE_ : List[Any] = MusicgenDecoderConfig( hidden_size=__a , ffn_dim=hidden_size * 4 , num_hidden_layers=__a , num_attention_heads=__a , ) return config @torch.no_grad() def _A (__a , __a=None , __a=None , __a="cpu" ) -> List[str]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Any = MusicGen.get_pretrained(__a , device=__a ) SCREAMING_SNAKE_CASE_ : Dict = decoder_config_from_checkpoint(__a ) SCREAMING_SNAKE_CASE_ : Optional[Any] = fairseq_model.lm.state_dict() SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : int = rename_state_dict( __a , hidden_size=decoder_config.hidden_size ) SCREAMING_SNAKE_CASE_ : Optional[Any] = TaEncoderModel.from_pretrained('''t5-base''' ) SCREAMING_SNAKE_CASE_ : List[str] = EncodecModel.from_pretrained('''facebook/encodec_32khz''' ) SCREAMING_SNAKE_CASE_ : int = MusicgenForCausalLM(__a ).eval() # load all decoder weights - expect that we'll be missing embeddings and enc-dec projection SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : List[str] = decoder.load_state_dict(__a , strict=__a ) for key in missing_keys.copy(): if key.startswith(('''text_encoder''', '''audio_encoder''') ) or key in EXPECTED_MISSING_KEYS: missing_keys.remove(__a ) if len(__a ) > 0: raise ValueError(f'Missing key(s) in state_dict: {missing_keys}' ) if len(__a ) > 0: raise ValueError(f'Unexpected key(s) in state_dict: {unexpected_keys}' ) # init the composite model SCREAMING_SNAKE_CASE_ : str = MusicgenForConditionalGeneration(text_encoder=__a , audio_encoder=__a , decoder=__a ) # load the pre-trained enc-dec projection (from the decoder state dict) model.enc_to_dec_proj.load_state_dict(__a ) # check we can do a forward pass SCREAMING_SNAKE_CASE_ : Dict = torch.arange(0 , 8 , dtype=torch.long ).reshape(2 , -1 ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = input_ids.reshape(2 * 4 , -1 ) with torch.no_grad(): SCREAMING_SNAKE_CASE_ : List[Any] = model(input_ids=__a , decoder_input_ids=__a ).logits if logits.shape != (8, 1, 20_48): raise ValueError('''Incorrect shape for logits''' ) # now construct the processor SCREAMING_SNAKE_CASE_ : str = AutoTokenizer.from_pretrained('''t5-base''' ) SCREAMING_SNAKE_CASE_ : str = AutoFeatureExtractor.from_pretrained('''facebook/encodec_32khz''' , padding_side='''left''' ) SCREAMING_SNAKE_CASE_ : Tuple = MusicgenProcessor(feature_extractor=__a , tokenizer=__a ) # set the appropriate bos/pad token ids SCREAMING_SNAKE_CASE_ : str = 20_48 SCREAMING_SNAKE_CASE_ : List[Any] = 20_48 # set other default generation config params SCREAMING_SNAKE_CASE_ : int = int(30 * audio_encoder.config.frame_rate ) SCREAMING_SNAKE_CASE_ : str = True SCREAMING_SNAKE_CASE_ : Optional[Any] = 3.0 if pytorch_dump_folder is not None: Path(__a ).mkdir(exist_ok=__a ) logger.info(f'Saving model {checkpoint} to {pytorch_dump_folder}' ) model.save_pretrained(__a ) processor.save_pretrained(__a ) if repo_id: logger.info(f'Pushing model {checkpoint} to {repo_id}' ) model.push_to_hub(__a ) processor.push_to_hub(__a ) if __name__ == "__main__": UpperCAmelCase_ : Dict = 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.""" ) UpperCAmelCase_ : Dict = parser.parse_args() convert_musicgen_checkpoint(args.checkpoint, args.pytorch_dump_folder, args.push_to_hub)
318
0
from typing import Dict, List, Optional, Tuple, Union import numpy as np from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict from ...image_transforms import ( center_crop, get_resize_output_image_size, normalize, rescale, resize, to_channel_dimension_format, ) from ...image_utils import ( IMAGENET_STANDARD_MEAN, IMAGENET_STANDARD_STD, ChannelDimension, ImageInput, PILImageResampling, make_list_of_images, to_numpy_array, valid_images, ) from ...utils import TensorType, is_torch_available, is_torch_tensor, logging if is_torch_available(): import torch UpperCAmelCase_ : List[Any] = logging.get_logger(__name__) class lowerCAmelCase__ ( __a ): '''simple docstring''' __UpperCamelCase = ["""pixel_values"""] def __init__( self : Tuple , lowercase_ : bool = True , lowercase_ : Optional[Dict[str, int]] = None , lowercase_ : PILImageResampling = PILImageResampling.BILINEAR , lowercase_ : bool = True , lowercase_ : Dict[str, int] = None , lowercase_ : bool = True , lowercase_ : Union[int, float] = 1 / 255 , lowercase_ : bool = True , lowercase_ : Optional[Union[float, List[float]]] = None , lowercase_ : Optional[Union[float, List[float]]] = None , **lowercase_ : Any , ): '''simple docstring''' super().__init__(**a__) SCREAMING_SNAKE_CASE_ : Optional[Any] = size if size is not None else {'''shortest_edge''': 256} SCREAMING_SNAKE_CASE_ : Tuple = get_size_dict(a__ , default_to_square=a__) SCREAMING_SNAKE_CASE_ : Union[str, Any] = crop_size if crop_size is not None else {'''height''': 224, '''width''': 224} SCREAMING_SNAKE_CASE_ : Tuple = get_size_dict(a__ , param_name='''crop_size''') SCREAMING_SNAKE_CASE_ : Any = do_resize SCREAMING_SNAKE_CASE_ : List[str] = size SCREAMING_SNAKE_CASE_ : List[Any] = resample SCREAMING_SNAKE_CASE_ : str = do_center_crop SCREAMING_SNAKE_CASE_ : List[str] = crop_size SCREAMING_SNAKE_CASE_ : Tuple = do_rescale SCREAMING_SNAKE_CASE_ : int = rescale_factor SCREAMING_SNAKE_CASE_ : Optional[Any] = do_normalize SCREAMING_SNAKE_CASE_ : str = image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN SCREAMING_SNAKE_CASE_ : str = image_std if image_std is not None else IMAGENET_STANDARD_STD def _SCREAMING_SNAKE_CASE ( self : List[Any] , lowercase_ : np.ndarray , lowercase_ : Dict[str, int] , lowercase_ : PILImageResampling = PILImageResampling.BICUBIC , lowercase_ : Optional[Union[str, ChannelDimension]] = None , **lowercase_ : Dict , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = get_size_dict(a__ , default_to_square=a__) if "shortest_edge" not in size: raise ValueError(F'The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}') SCREAMING_SNAKE_CASE_ : List[str] = get_resize_output_image_size(a__ , size=size['''shortest_edge'''] , default_to_square=a__) return resize(a__ , size=a__ , resample=a__ , data_format=a__ , **a__) def _SCREAMING_SNAKE_CASE ( self : int , lowercase_ : np.ndarray , lowercase_ : Dict[str, int] , lowercase_ : Optional[Union[str, ChannelDimension]] = None , **lowercase_ : Union[str, Any] , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = get_size_dict(a__) if "height" not in size or "width" not in size: raise ValueError(F'The `size` parameter must contain the keys `height` and `width`. Got {size.keys()}') return center_crop(a__ , size=(size['''height'''], size['''width''']) , data_format=a__ , **a__) def _SCREAMING_SNAKE_CASE ( self : Any , lowercase_ : np.ndarray , lowercase_ : float , lowercase_ : Optional[Union[str, ChannelDimension]] = None , **lowercase_ : List[str]): '''simple docstring''' return rescale(a__ , scale=a__ , data_format=a__ , **a__) def _SCREAMING_SNAKE_CASE ( self : List[Any] , lowercase_ : np.ndarray , lowercase_ : Union[float, List[float]] , lowercase_ : Union[float, List[float]] , lowercase_ : Optional[Union[str, ChannelDimension]] = None , **lowercase_ : Optional[Any] , ): '''simple docstring''' return normalize(a__ , mean=a__ , std=a__ , data_format=a__ , **a__) def _SCREAMING_SNAKE_CASE ( self : str , lowercase_ : ImageInput , lowercase_ : Optional[bool] = None , lowercase_ : Dict[str, int] = None , lowercase_ : PILImageResampling = None , lowercase_ : bool = None , lowercase_ : Dict[str, int] = None , lowercase_ : Optional[bool] = None , lowercase_ : Optional[float] = None , lowercase_ : Optional[bool] = None , lowercase_ : Optional[Union[float, List[float]]] = None , lowercase_ : Optional[Union[float, List[float]]] = None , lowercase_ : Optional[Union[str, TensorType]] = None , lowercase_ : Union[str, ChannelDimension] = ChannelDimension.FIRST , **lowercase_ : Union[str, Any] , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = do_resize if do_resize is not None else self.do_resize SCREAMING_SNAKE_CASE_ : Optional[Any] = size if size is not None else self.size SCREAMING_SNAKE_CASE_ : Dict = get_size_dict(a__ , default_to_square=a__) SCREAMING_SNAKE_CASE_ : Optional[int] = resample if resample is not None else self.resample SCREAMING_SNAKE_CASE_ : str = do_center_crop if do_center_crop is not None else self.do_center_crop SCREAMING_SNAKE_CASE_ : int = crop_size if crop_size is not None else self.crop_size SCREAMING_SNAKE_CASE_ : int = get_size_dict(a__ , param_name='''crop_size''') SCREAMING_SNAKE_CASE_ : Dict = do_rescale if do_rescale is not None else self.do_rescale SCREAMING_SNAKE_CASE_ : List[str] = rescale_factor if rescale_factor is not None else self.rescale_factor SCREAMING_SNAKE_CASE_ : List[Any] = do_normalize if do_normalize is not None else self.do_normalize SCREAMING_SNAKE_CASE_ : Union[str, Any] = image_mean if image_mean is not None else self.image_mean SCREAMING_SNAKE_CASE_ : Tuple = image_std if image_std is not None else self.image_std SCREAMING_SNAKE_CASE_ : List[Any] = make_list_of_images(a__) if not valid_images(a__): raise ValueError( '''Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, ''' '''torch.Tensor, tf.Tensor or jax.ndarray.''') if do_resize and size is None: raise ValueError('''Size must be specified if do_resize is True.''') if do_center_crop and crop_size is None: raise ValueError('''Crop size must be specified if do_center_crop is True.''') if do_rescale and rescale_factor is None: raise ValueError('''Rescale factor must be specified if do_rescale is True.''') if do_normalize and (image_mean is None or image_std is None): raise ValueError('''Image mean and std must be specified if do_normalize is True.''') # All transformations expect numpy arrays. SCREAMING_SNAKE_CASE_ : Tuple = [to_numpy_array(a__) for image in images] if do_resize: SCREAMING_SNAKE_CASE_ : Optional[Any] = [self.resize(image=a__ , size=a__ , resample=a__) for image in images] if do_center_crop: SCREAMING_SNAKE_CASE_ : str = [self.center_crop(image=a__ , size=a__) for image in images] if do_rescale: SCREAMING_SNAKE_CASE_ : Tuple = [self.rescale(image=a__ , scale=a__) for image in images] if do_normalize: SCREAMING_SNAKE_CASE_ : Union[str, Any] = [self.normalize(image=a__ , mean=a__ , std=a__) for image in images] SCREAMING_SNAKE_CASE_ : Union[str, Any] = [to_channel_dimension_format(a__ , a__) for image in images] SCREAMING_SNAKE_CASE_ : Dict = {'''pixel_values''': images} return BatchFeature(data=a__ , tensor_type=a__) def _SCREAMING_SNAKE_CASE ( self : Tuple , lowercase_ : Any , lowercase_ : List[Tuple] = None): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = outputs.logits # Resize logits and compute semantic segmentation maps if target_sizes is not None: if len(a__) != len(a__): raise ValueError( '''Make sure that you pass in as many target sizes as the batch dimension of the logits''') if is_torch_tensor(a__): SCREAMING_SNAKE_CASE_ : List[Any] = target_sizes.numpy() SCREAMING_SNAKE_CASE_ : Optional[Any] = [] for idx in range(len(a__)): SCREAMING_SNAKE_CASE_ : List[Any] = torch.nn.functional.interpolate( logits[idx].unsqueeze(dim=0) , size=target_sizes[idx] , mode='''bilinear''' , align_corners=a__) SCREAMING_SNAKE_CASE_ : List[str] = resized_logits[0].argmax(dim=0) semantic_segmentation.append(a__) else: SCREAMING_SNAKE_CASE_ : Optional[Any] = logits.argmax(dim=1) SCREAMING_SNAKE_CASE_ : List[str] = [semantic_segmentation[i] for i in range(semantic_segmentation.shape[0])] return semantic_segmentation
360
"""simple docstring""" from pathlib import Path import numpy as np from PIL import Image def _A (__a ) -> np.ndarray: """simple docstring""" SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Optional[int] = rgb[:, :, 0], rgb[:, :, 1], rgb[:, :, 2] return 0.29_89 * r + 0.58_70 * g + 0.11_40 * b def _A (__a ) -> np.ndarray: """simple docstring""" return (gray > 1_27) & (gray <= 2_55) def _A (__a , __a ) -> np.ndarray: """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[Any] = np.zeros_like(__a ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = np.zeros( (image.shape[0] + kernel.shape[0] - 1, image.shape[1] + kernel.shape[1] - 1) ) # Copy image to padded image SCREAMING_SNAKE_CASE_ : Union[str, Any] = image # Iterate over image & apply kernel for x in range(image.shape[1] ): for y in range(image.shape[0] ): SCREAMING_SNAKE_CASE_ : Optional[Any] = ( kernel * image_padded[y : y + kernel.shape[0], x : x + kernel.shape[1]] ).sum() SCREAMING_SNAKE_CASE_ : Any = int(summation > 0 ) return output if __name__ == "__main__": # read original image UpperCAmelCase_ : Dict = Path(__file__).resolve().parent / """image_data""" / """lena.jpg""" UpperCAmelCase_ : List[Any] = np.array(Image.open(lena_path)) # kernel to be applied UpperCAmelCase_ : Any = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]]) UpperCAmelCase_ : Tuple = dilation(gray_to_binary(rgb_to_gray(lena)), structuring_element) # Save the output image UpperCAmelCase_ : List[str] = Image.fromarray(output).convert("""RGB""") pil_img.save("""result_dilation.png""")
318
0
"""simple docstring""" import coval # From: git+https://github.com/ns-moosavi/coval.git # noqa: F401 from coval.conll import reader, util from coval.eval import evaluator import datasets UpperCAmelCase_ = datasets.logging.get_logger(__name__) UpperCAmelCase_ = "\\n@InProceedings{moosavi2019minimum,\n author = { Nafise Sadat Moosavi, Leo Born, Massimo Poesio and Michael Strube},\n title = {Using Automatically Extracted Minimum Spans to Disentangle Coreference Evaluation from Boundary Detection},\n year = {2019},\n booktitle = {Proceedings of the 57th Annual Meeting of\n the Association for Computational Linguistics (Volume 1: Long Papers)},\n publisher = {Association for Computational Linguistics},\n address = {Florence, Italy},\n}\n\n@inproceedings{10.3115/1072399.1072405,\nauthor = {Vilain, Marc and Burger, John and Aberdeen, John and Connolly, Dennis and Hirschman, Lynette},\ntitle = {A Model-Theoretic Coreference Scoring Scheme},\nyear = {1995},\nisbn = {1558604022},\npublisher = {Association for Computational Linguistics},\naddress = {USA},\nurl = {https://doi.org/10.3115/1072399.1072405},\ndoi = {10.3115/1072399.1072405},\nbooktitle = {Proceedings of the 6th Conference on Message Understanding},\npages = {45–52},\nnumpages = {8},\nlocation = {Columbia, Maryland},\nseries = {MUC6 ’95}\n}\n\n@INPROCEEDINGS{Bagga98algorithmsfor,\n author = {Amit Bagga and Breck Baldwin},\n title = {Algorithms for Scoring Coreference Chains},\n booktitle = {In The First International Conference on Language Resources and Evaluation Workshop on Linguistics Coreference},\n year = {1998},\n pages = {563--566}\n}\n\n@INPROCEEDINGS{Luo05oncoreference,\n author = {Xiaoqiang Luo},\n title = {On coreference resolution performance metrics},\n booktitle = {In Proc. of HLT/EMNLP},\n year = {2005},\n pages = {25--32},\n publisher = {URL}\n}\n\n@inproceedings{moosavi-strube-2016-coreference,\n title = \"Which Coreference Evaluation Metric Do You Trust? A Proposal for a Link-based Entity Aware Metric\",\n author = \"Moosavi, Nafise Sadat and\n Strube, Michael\",\n booktitle = \"Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)\",\n month = aug,\n year = \"2016\",\n address = \"Berlin, Germany\",\n publisher = \"Association for Computational Linguistics\",\n url = \"https://www.aclweb.org/anthology/P16-1060\",\n doi = \"10.18653/v1/P16-1060\",\n pages = \"632--642\",\n}\n\n" UpperCAmelCase_ = "\\nCoVal is a coreference evaluation tool for the CoNLL and ARRAU datasets which\nimplements of the common evaluation metrics including MUC [Vilain et al, 1995],\nB-cubed [Bagga and Baldwin, 1998], CEAFe [Luo et al., 2005],\nLEA [Moosavi and Strube, 2016] and the averaged CoNLL score\n(the average of the F1 values of MUC, B-cubed and CEAFe)\n[Denis and Baldridge, 2009a; Pradhan et al., 2011].\n\nThis wrapper of CoVal currently only work with CoNLL line format:\nThe CoNLL format has one word per line with all the annotation for this word in column separated by spaces:\nColumn Type Description\n1 Document ID This is a variation on the document filename\n2 Part number Some files are divided into multiple parts numbered as 000, 001, 002, ... etc.\n3 Word number\n4 Word itself This is the token as segmented/tokenized in the Treebank. Initially the *_skel file contain the placeholder [WORD] which gets replaced by the actual token from the Treebank which is part of the OntoNotes release.\n5 Part-of-Speech\n6 Parse bit This is the bracketed structure broken before the first open parenthesis in the parse, and the word/part-of-speech leaf replaced with a *. The full parse can be created by substituting the asterix with the \"([pos] [word])\" string (or leaf) and concatenating the items in the rows of that column.\n7 Predicate lemma The predicate lemma is mentioned for the rows for which we have semantic role information. All other rows are marked with a \"-\"\n8 Predicate Frameset ID This is the PropBank frameset ID of the predicate in Column 7.\n9 Word sense This is the word sense of the word in Column 3.\n10 Speaker/Author This is the speaker or author name where available. Mostly in Broadcast Conversation and Web Log data.\n11 Named Entities These columns identifies the spans representing various named entities.\n12:N Predicate Arguments There is one column each of predicate argument structure information for the predicate mentioned in Column 7.\nN Coreference Coreference chain information encoded in a parenthesis structure.\nMore informations on the format can be found here (section \"*_conll File Format\"): http://www.conll.cemantix.org/2012/data.html\n\nDetails on the evaluation on CoNLL can be found here: https://github.com/ns-moosavi/coval/blob/master/conll/README.md\n\nCoVal code was written by @ns-moosavi.\nSome parts are borrowed from https://github.com/clarkkev/deep-coref/blob/master/evaluation.py\nThe test suite is taken from https://github.com/conll/reference-coreference-scorers/\nMention evaluation and the test suite are added by @andreasvc.\nParsing CoNLL files is developed by Leo Born.\n" UpperCAmelCase_ = "\nCalculates coreference evaluation metrics.\nArgs:\n predictions: list of sentences. Each sentence is a list of word predictions to score in the CoNLL format.\n Each prediction is a word with its annotations as a string made of columns joined with spaces.\n Only columns 4, 5, 6 and the last column are used (word, POS, Pars and coreference annotation)\n See the details on the format in the description of the metric.\n references: list of sentences. Each sentence is a list of word reference to score in the CoNLL format.\n Each reference is a word with its annotations as a string made of columns joined with spaces.\n Only columns 4, 5, 6 and the last column are used (word, POS, Pars and coreference annotation)\n See the details on the format in the description of the metric.\n keep_singletons: After extracting all mentions of key or system files,\n mentions whose corresponding coreference chain is of size one,\n are considered as singletons. The default evaluation mode will include\n singletons in evaluations if they are included in the key or the system files.\n By setting 'keep_singletons=False', all singletons in the key and system files\n will be excluded from the evaluation.\n NP_only: Most of the recent coreference resolvers only resolve NP mentions and\n leave out the resolution of VPs. By setting the 'NP_only' option, the scorer will only evaluate the resolution of NPs.\n min_span: By setting 'min_span', the scorer reports the results based on automatically detected minimum spans.\n Minimum spans are determined using the MINA algorithm.\n\nReturns:\n 'mentions': mentions\n 'muc': MUC metric [Vilain et al, 1995]\n 'bcub': B-cubed [Bagga and Baldwin, 1998]\n 'ceafe': CEAFe [Luo et al., 2005]\n 'lea': LEA [Moosavi and Strube, 2016]\n 'conll_score': averaged CoNLL score (the average of the F1 values of MUC, B-cubed and CEAFe)\n\nExamples:\n\n >>> coval = datasets.load_metric('coval')\n >>> words = ['bc/cctv/00/cctv_0005 0 0 Thank VBP (TOP(S(VP* thank 01 1 Xu_li * (V*) * -',\n ... 'bc/cctv/00/cctv_0005 0 1 you PRP (NP*) - - - Xu_li * (ARG1*) (ARG0*) (116)',\n ... 'bc/cctv/00/cctv_0005 0 2 everyone NN (NP*) - - - Xu_li * (ARGM-DIS*) * (116)',\n ... 'bc/cctv/00/cctv_0005 0 3 for IN (PP* - - - Xu_li * (ARG2* * -',\n ... 'bc/cctv/00/cctv_0005 0 4 watching VBG (S(VP*)))) watch 01 1 Xu_li * *) (V*) -',\n ... 'bc/cctv/00/cctv_0005 0 5 . . *)) - - - Xu_li * * * -']\n >>> references = [words]\n >>> predictions = [words]\n >>> results = coval.compute(predictions=predictions, references=references)\n >>> print(results) # doctest:+ELLIPSIS\n {'mentions/recall': 1.0,[...] 'conll_score': 100.0}\n" def _A (__a , __a , __a=False , __a=False , __a=True , __a=False , __a="dummy_doc" ) -> Any: """simple docstring""" SCREAMING_SNAKE_CASE_ : Dict = {doc: key_lines} SCREAMING_SNAKE_CASE_ : Any = {doc: sys_lines} SCREAMING_SNAKE_CASE_ : int = {} SCREAMING_SNAKE_CASE_ : List[Any] = 0 SCREAMING_SNAKE_CASE_ : Any = 0 SCREAMING_SNAKE_CASE_ : Optional[int] = 0 SCREAMING_SNAKE_CASE_ : Optional[Any] = 0 SCREAMING_SNAKE_CASE_ : int = 0 SCREAMING_SNAKE_CASE_ : List[str] = 0 SCREAMING_SNAKE_CASE_ : Tuple = reader.get_doc_mentions(__a , key_doc_lines[doc] , __a ) key_singletons_num += singletons_num if NP_only or min_span: SCREAMING_SNAKE_CASE_ : int = reader.set_annotated_parse_trees(__a , key_doc_lines[doc] , __a , __a ) SCREAMING_SNAKE_CASE_ : str = reader.get_doc_mentions(__a , sys_doc_lines[doc] , __a ) sys_singletons_num += singletons_num if NP_only or min_span: SCREAMING_SNAKE_CASE_ : Tuple = reader.set_annotated_parse_trees(__a , key_doc_lines[doc] , __a , __a ) if remove_nested: SCREAMING_SNAKE_CASE_ : Tuple = reader.remove_nested_coref_mentions(__a , __a ) key_nested_coref_num += nested_mentions key_removed_nested_clusters += removed_clusters SCREAMING_SNAKE_CASE_ : List[str] = reader.remove_nested_coref_mentions(__a , __a ) sys_nested_coref_num += nested_mentions sys_removed_nested_clusters += removed_clusters SCREAMING_SNAKE_CASE_ : Union[str, Any] = reader.get_mention_assignments(__a , __a ) SCREAMING_SNAKE_CASE_ : Optional[int] = reader.get_mention_assignments(__a , __a ) SCREAMING_SNAKE_CASE_ : str = (key_clusters, sys_clusters, key_mention_sys_cluster, sys_mention_key_cluster) if remove_nested: logger.info( '''Number of removed nested coreferring mentions in the key ''' f'annotation: {key_nested_coref_num}; and system annotation: {sys_nested_coref_num}' ) logger.info( '''Number of resulting singleton clusters in the key ''' f'annotation: {key_removed_nested_clusters}; and system annotation: {sys_removed_nested_clusters}' ) if not keep_singletons: logger.info( f'{key_singletons_num:d} and {sys_singletons_num:d} singletons are removed from the key and system ' '''files, respectively''' ) return doc_coref_infos def _A (__a , __a , __a , __a , __a , __a , __a ) -> Union[str, Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[int] = get_coref_infos(__a , __a , __a , __a , __a , __a ) SCREAMING_SNAKE_CASE_ : Dict = {} SCREAMING_SNAKE_CASE_ : Dict = 0 SCREAMING_SNAKE_CASE_ : Tuple = 0 for name, metric in metrics: SCREAMING_SNAKE_CASE_ : List[str] = evaluator.evaluate_documents(__a , __a , beta=1 ) if name in ["muc", "bcub", "ceafe"]: conll += fa conll_subparts_num += 1 output_scores.update({f'{name}/recall': recall, f'{name}/precision': precision, f'{name}/f1': fa} ) logger.info( name.ljust(10 ) , f'Recall: {recall * 1_00:.2f}' , f' Precision: {precision * 1_00:.2f}' , f' F1: {fa * 1_00:.2f}' , ) if conll_subparts_num == 3: SCREAMING_SNAKE_CASE_ : Optional[int] = (conll / 3) * 1_00 logger.info(f'CoNLL score: {conll:.2f}' ) output_scores.update({'''conll_score''': conll} ) return output_scores def _A (__a ) -> List[str]: """simple docstring""" SCREAMING_SNAKE_CASE_ : int = False for line in key_lines: if not line.startswith('''#''' ): if len(line.split() ) > 6: SCREAMING_SNAKE_CASE_ : List[str] = line.split()[5] if not parse_col == "-": SCREAMING_SNAKE_CASE_ : Optional[int] = True break else: break return has_gold_parse @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class lowerCAmelCase__ ( datasets.Metric ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { '''predictions''': datasets.Sequence(datasets.Value('''string''')), '''references''': datasets.Sequence(datasets.Value('''string''')), }) , codebase_urls=['''https://github.com/ns-moosavi/coval'''] , reference_urls=[ '''https://github.com/ns-moosavi/coval''', '''https://www.aclweb.org/anthology/P16-1060''', '''http://www.conll.cemantix.org/2012/data.html''', ] , ) def _SCREAMING_SNAKE_CASE ( self : str , lowercase_ : Any , lowercase_ : Dict , lowercase_ : List[str]=True , lowercase_ : Optional[Any]=False , lowercase_ : List[Any]=False , lowercase_ : Tuple=False): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = [ ('''mentions''', evaluator.mentions), ('''muc''', evaluator.muc), ('''bcub''', evaluator.b_cubed), ('''ceafe''', evaluator.ceafe), ('''lea''', evaluator.lea), ] if min_span: SCREAMING_SNAKE_CASE_ : List[Any] = util.check_gold_parse_annotation(__A) if not has_gold_parse: raise NotImplementedError('''References should have gold parse annotation to use \'min_span\'.''') # util.parse_key_file(key_file) # key_file = key_file + ".parsed" SCREAMING_SNAKE_CASE_ : Union[str, Any] = evaluate( key_lines=__A , sys_lines=__A , metrics=__A , NP_only=__A , remove_nested=__A , keep_singletons=__A , min_span=__A , ) return score
361
"""simple docstring""" from collections import defaultdict def _A (__a , __a ) -> bool: """simple docstring""" SCREAMING_SNAKE_CASE_ : Dict = first_str.lower().strip() SCREAMING_SNAKE_CASE_ : List[Any] = second_str.lower().strip() # Remove whitespace SCREAMING_SNAKE_CASE_ : Dict = first_str.replace(''' ''' , '''''' ) SCREAMING_SNAKE_CASE_ : Optional[Any] = second_str.replace(''' ''' , '''''' ) # Strings of different lengths are not anagrams if len(__a ) != len(__a ): return False # Default values for count should be 0 SCREAMING_SNAKE_CASE_ : defaultdict[str, int] = defaultdict(__a ) # For each character in input strings, # increment count in the corresponding for i in range(len(__a ) ): count[first_str[i]] += 1 count[second_str[i]] -= 1 return all(_count == 0 for _count in count.values() ) if __name__ == "__main__": from doctest import testmod testmod() UpperCAmelCase_ : Any = input("""Enter the first string """).strip() UpperCAmelCase_ : Optional[int] = input("""Enter the second string """).strip() UpperCAmelCase_ : Union[str, Any] = check_anagrams(input_a, input_b) print(f'''{input_a} and {input_b} are {'' if status else 'not '}anagrams.''')
318
0
"""simple docstring""" from PIL import Image def _A (__a , __a ) -> Image: """simple docstring""" def brightness(__a ) -> float: return 1_28 + level + (c - 1_28) if not -2_55.0 <= level <= 2_55.0: raise ValueError('''level must be between -255.0 (black) and 255.0 (white)''' ) return img.point(__snake_case ) if __name__ == "__main__": # Load image with Image.open("""image_data/lena.jpg""") as img: # Change brightness to 100 UpperCAmelCase_ : str = change_brightness(img, 100) brigt_img.save("""image_data/lena_brightness.png""", format="""png""")
362
"""simple docstring""" import argparse from collections import defaultdict import yaml UpperCAmelCase_ : Optional[Any] = """docs/source/en/_toctree.yml""" def _A (__a ) -> Union[str, Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : str = defaultdict(__a ) for doc in model_doc: counts[doc["local"]] += 1 SCREAMING_SNAKE_CASE_ : List[Any] = [key for key, value in counts.items() if value > 1] SCREAMING_SNAKE_CASE_ : int = [] for duplicate_key in duplicates: SCREAMING_SNAKE_CASE_ : List[str] = list({doc['''title'''] for doc in model_doc if doc['''local'''] == duplicate_key} ) if len(__a ) > 1: raise ValueError( f'{duplicate_key} is present several times in the documentation table of content at ' '''`docs/source/en/_toctree.yml` with different *Title* values. Choose one of those and remove the ''' '''others.''' ) # Only add this once new_doc.append({'''local''': duplicate_key, '''title''': titles[0]} ) # Add none duplicate-keys new_doc.extend([doc for doc in model_doc if counts[doc['''local''']] == 1] ) # Sort return sorted(__a , key=lambda __a : s["title"].lower() ) def _A (__a=False ) -> Tuple: """simple docstring""" with open(__a , encoding='''utf-8''' ) as f: SCREAMING_SNAKE_CASE_ : Dict = yaml.safe_load(f.read() ) # Get to the API doc SCREAMING_SNAKE_CASE_ : Any = 0 while content[api_idx]["title"] != "API": api_idx += 1 SCREAMING_SNAKE_CASE_ : str = content[api_idx]['''sections'''] # Then to the model doc SCREAMING_SNAKE_CASE_ : List[Any] = 0 while api_doc[model_idx]["title"] != "Models": model_idx += 1 SCREAMING_SNAKE_CASE_ : Optional[int] = api_doc[model_idx]['''sections'''] SCREAMING_SNAKE_CASE_ : str = [(idx, section) for idx, section in enumerate(__a ) if '''sections''' in section] SCREAMING_SNAKE_CASE_ : Optional[Any] = False for idx, modality_doc in modalities_docs: SCREAMING_SNAKE_CASE_ : List[str] = modality_doc['''sections'''] SCREAMING_SNAKE_CASE_ : Union[str, Any] = clean_model_doc_toc(__a ) if old_modality_doc != new_modality_doc: SCREAMING_SNAKE_CASE_ : str = True if overwrite: SCREAMING_SNAKE_CASE_ : Optional[int] = new_modality_doc if diff: if overwrite: SCREAMING_SNAKE_CASE_ : List[Any] = model_doc SCREAMING_SNAKE_CASE_ : int = api_doc with open(__a , '''w''' , encoding='''utf-8''' ) as f: f.write(yaml.dump(__a , allow_unicode=__a ) ) else: raise ValueError( '''The model doc part of the table of content is not properly sorted, run `make style` to fix this.''' ) if __name__ == "__main__": UpperCAmelCase_ : List[str] = argparse.ArgumentParser() parser.add_argument("""--fix_and_overwrite""", action="""store_true""", help="""Whether to fix inconsistencies.""") UpperCAmelCase_ : Tuple = parser.parse_args() check_model_doc(args.fix_and_overwrite)
318
0
"""simple docstring""" import copy from dataclasses import dataclass, field from typing import ClassVar, Dict from ..features import Audio, ClassLabel, Features from .base import TaskTemplate @dataclass(frozen=_snake_case ) class lowerCAmelCase__ ( _snake_case ): '''simple docstring''' __UpperCamelCase = field(default="audio-classification" , metadata={"include_in_asdict_even_if_is_default": True} ) __UpperCamelCase = Features({"audio": Audio()} ) __UpperCamelCase = Features({"labels": ClassLabel} ) __UpperCamelCase = "audio" __UpperCamelCase = "labels" def _SCREAMING_SNAKE_CASE ( self : Any , lowercase_ : Optional[int]): '''simple docstring''' if self.label_column not in features: raise ValueError(F'Column {self.label_column} is not present in features.') if not isinstance(features[self.label_column] , UpperCamelCase__): raise ValueError(F'Column {self.label_column} is not a ClassLabel.') SCREAMING_SNAKE_CASE_ : List[str] = copy.deepcopy(self) SCREAMING_SNAKE_CASE_ : Optional[int] = self.label_schema.copy() SCREAMING_SNAKE_CASE_ : List[Any] = features[self.label_column] SCREAMING_SNAKE_CASE_ : Optional[int] = label_schema return task_template @property def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' return { self.audio_column: "audio", self.label_column: "labels", }
363
"""simple docstring""" from ...utils import ( OptionalDependencyNotAvailable, is_torch_available, is_transformers_available, is_transformers_version, ) try: if not (is_transformers_available() and is_torch_available() and is_transformers_version(""">=""", """4.25.0""")): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ...utils.dummy_torch_and_transformers_objects import ( VersatileDiffusionDualGuidedPipeline, VersatileDiffusionImageVariationPipeline, VersatileDiffusionPipeline, VersatileDiffusionTextToImagePipeline, ) else: from .modeling_text_unet import UNetFlatConditionModel from .pipeline_versatile_diffusion import VersatileDiffusionPipeline from .pipeline_versatile_diffusion_dual_guided import VersatileDiffusionDualGuidedPipeline from .pipeline_versatile_diffusion_image_variation import VersatileDiffusionImageVariationPipeline from .pipeline_versatile_diffusion_text_to_image import VersatileDiffusionTextToImagePipeline
318
0
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available UpperCAmelCase_ : List[Any] = { """configuration_megatron_bert""": ["""MEGATRON_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """MegatronBertConfig"""], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase_ : Union[str, Any] = [ """MEGATRON_BERT_PRETRAINED_MODEL_ARCHIVE_LIST""", """MegatronBertForCausalLM""", """MegatronBertForMaskedLM""", """MegatronBertForMultipleChoice""", """MegatronBertForNextSentencePrediction""", """MegatronBertForPreTraining""", """MegatronBertForQuestionAnswering""", """MegatronBertForSequenceClassification""", """MegatronBertForTokenClassification""", """MegatronBertModel""", """MegatronBertPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_megatron_bert import MEGATRON_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, MegatronBertConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_megatron_bert import ( MEGATRON_BERT_PRETRAINED_MODEL_ARCHIVE_LIST, MegatronBertForCausalLM, MegatronBertForMaskedLM, MegatronBertForMultipleChoice, MegatronBertForNextSentencePrediction, MegatronBertForPreTraining, MegatronBertForQuestionAnswering, MegatronBertForSequenceClassification, MegatronBertForTokenClassification, MegatronBertModel, MegatronBertPreTrainedModel, ) else: import sys UpperCAmelCase_ : int = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
364
"""simple docstring""" from __future__ import annotations UpperCAmelCase_ : List[str] = list[list[int]] # assigning initial values to the grid UpperCAmelCase_ : Matrix = [ [3, 0, 6, 5, 0, 8, 4, 0, 0], [5, 2, 0, 0, 0, 0, 0, 0, 0], [0, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] # a grid with no solution UpperCAmelCase_ : Matrix = [ [5, 0, 6, 5, 0, 8, 4, 0, 3], [5, 2, 0, 0, 0, 0, 0, 0, 2], [1, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] def _A (__a , __a , __a , __a ) -> bool: """simple docstring""" for i in range(9 ): if grid[row][i] == n or grid[i][column] == n: return False for i in range(3 ): for j in range(3 ): if grid[(row - row % 3) + i][(column - column % 3) + j] == n: return False return True def _A (__a ) -> tuple[int, int] | None: """simple docstring""" for i in range(9 ): for j in range(9 ): if grid[i][j] == 0: return i, j return None def _A (__a ) -> Matrix | None: """simple docstring""" if location := find_empty_location(__a ): SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Dict = location else: # If the location is ``None``, then the grid is solved. return grid for digit in range(1 , 10 ): if is_safe(__a , __a , __a , __a ): SCREAMING_SNAKE_CASE_ : Tuple = digit if sudoku(__a ) is not None: return grid SCREAMING_SNAKE_CASE_ : Any = 0 return None def _A (__a ) -> None: """simple docstring""" for row in grid: for cell in row: print(__a , end=''' ''' ) print() if __name__ == "__main__": # make a copy of grid so that you can compare with the unmodified grid for example_grid in (initial_grid, no_solution): print("""\nExample grid:\n""" + """=""" * 20) print_solution(example_grid) print("""\nExample grid solution:""") UpperCAmelCase_ : str = sudoku(example_grid) if solution is not None: print_solution(solution) else: print("""Cannot find a solution.""")
318
0
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_tokenizers_available, is_torch_available, is_vision_available, ) UpperCAmelCase_ : int = { """configuration_owlvit""": [ """OWLVIT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """OwlViTConfig""", """OwlViTOnnxConfig""", """OwlViTTextConfig""", """OwlViTVisionConfig""", ], """processing_owlvit""": ["""OwlViTProcessor"""], } try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase_ : int = ["""OwlViTFeatureExtractor"""] UpperCAmelCase_ : Dict = ["""OwlViTImageProcessor"""] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase_ : Tuple = [ """OWLVIT_PRETRAINED_MODEL_ARCHIVE_LIST""", """OwlViTModel""", """OwlViTPreTrainedModel""", """OwlViTTextModel""", """OwlViTVisionModel""", """OwlViTForObjectDetection""", ] if TYPE_CHECKING: from .configuration_owlvit import ( OWLVIT_PRETRAINED_CONFIG_ARCHIVE_MAP, OwlViTConfig, OwlViTOnnxConfig, OwlViTTextConfig, OwlViTVisionConfig, ) from .processing_owlvit import OwlViTProcessor try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_owlvit import OwlViTFeatureExtractor from .image_processing_owlvit import OwlViTImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_owlvit import ( OWLVIT_PRETRAINED_MODEL_ARCHIVE_LIST, OwlViTForObjectDetection, OwlViTModel, OwlViTPreTrainedModel, OwlViTTextModel, OwlViTVisionModel, ) else: import sys UpperCAmelCase_ : Union[str, Any] = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
365
"""simple docstring""" from itertools import permutations def _A (__a ) -> bool: """simple docstring""" if num[3] % 2 != 0: return False if (num[2] + num[3] + num[4]) % 3 != 0: return False if num[5] % 5 != 0: return False SCREAMING_SNAKE_CASE_ : List[str] = [7, 11, 13, 17] for i, test in enumerate(__a ): if (num[i + 4] * 1_00 + num[i + 5] * 10 + num[i + 6]) % test != 0: return False return True def _A (__a = 10 ) -> int: """simple docstring""" return sum( int(''''''.join(map(__a , __a ) ) ) for num in permutations(range(__a ) ) if is_substring_divisible(__a ) ) if __name__ == "__main__": print(f'''{solution() = }''')
318
0
"""simple docstring""" from datetime import datetime import requests def _A (__a ): """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[int] = '''https://downloadgram.net/wp-json/wppress/video-downloader/video?url=''' SCREAMING_SNAKE_CASE_ : Optional[Any] = requests.get(base_url + url ).json()[0]['''urls'''][0]['''src'''] return requests.get(lowerCAmelCase__ ).content if __name__ == "__main__": UpperCAmelCase_ : Optional[Any] = input("""Enter Video/IGTV url: """).strip() UpperCAmelCase_ : Optional[Any] = f'''{datetime.now():%Y-%m-%d_%H:%M:%S}.mp4''' with open(file_name, """wb""") as fp: fp.write(download_video(url)) print(f'''Done. Video saved to disk as {file_name}.''')
366
"""simple docstring""" UpperCAmelCase_ : List[Any] = 9.8_0_6_6_5 def _A (__a , __a , __a = g ) -> float: """simple docstring""" if fluid_density <= 0: raise ValueError('''Impossible fluid density''' ) if volume < 0: raise ValueError('''Impossible Object volume''' ) if gravity <= 0: raise ValueError('''Impossible Gravity''' ) return fluid_density * gravity * volume if __name__ == "__main__": import doctest # run doctest doctest.testmod()
318
0
"""simple docstring""" from __future__ import annotations import csv import requests from bsa import BeautifulSoup def _A (__a = "" ) -> Tuple: """simple docstring""" SCREAMING_SNAKE_CASE_ : Dict = url or '''https://www.imdb.com/chart/top/?ref_=nv_mv_250''' SCREAMING_SNAKE_CASE_ : Any = BeautifulSoup(requests.get(__a ).text , '''html.parser''' ) SCREAMING_SNAKE_CASE_ : List[Any] = soup.find_all('''td''' , attrs='''titleColumn''' ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = soup.find_all('''td''' , class_='''ratingColumn imdbRating''' ) return { title.a.text: float(rating.strong.text ) for title, rating in zip(__a , __a ) } def _A (__a = "IMDb_Top_250_Movies.csv" ) -> List[str]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Any = get_imdb_top_aaa_movies() with open(__a , '''w''' , newline='''''' ) as out_file: SCREAMING_SNAKE_CASE_ : int = csv.writer(__a ) writer.writerow(['''Movie title''', '''IMDb rating'''] ) for title, rating in movies.items(): writer.writerow([title, rating] ) if __name__ == "__main__": write_movies()
367
"""simple docstring""" # tests directory-specific settings - this file is run automatically # by pytest before any tests are run import sys import warnings from os.path import abspath, dirname, join # allow having multiple repository checkouts and not needing to remember to rerun # 'pip install -e .[dev]' when switching between checkouts and running tests. UpperCAmelCase_ : Union[str, Any] = abspath(join(dirname(dirname(dirname(__file__))), """src""")) sys.path.insert(1, git_repo_path) # silence FutureWarning warnings in tests since often we can't act on them until # they become normal warnings - i.e. the tests still need to test the current functionality warnings.simplefilter(action="""ignore""", category=FutureWarning) def _A (__a ) -> Union[str, Any]: """simple docstring""" from transformers.testing_utils import pytest_addoption_shared pytest_addoption_shared(__a ) def _A (__a ) -> Any: """simple docstring""" from transformers.testing_utils import pytest_terminal_summary_main SCREAMING_SNAKE_CASE_ : Optional[Any] = terminalreporter.config.getoption('''--make-reports''' ) if make_reports: pytest_terminal_summary_main(__a , id=__a )
318
0
"""simple docstring""" from pathlib import Path import fire from tqdm import tqdm def _A (__a="ro" , __a="en" , __a="wmt16" , __a=None ) -> None: """simple docstring""" try: import datasets except (ModuleNotFoundError, ImportError): raise ImportError('''run pip install datasets''' ) SCREAMING_SNAKE_CASE_ : Optional[int] = f'{src_lang}-{tgt_lang}' print(f'Converting {dataset}-{pair}' ) SCREAMING_SNAKE_CASE_ : Optional[Any] = datasets.load_dataset(snake_case_ , snake_case_ ) if save_dir is None: SCREAMING_SNAKE_CASE_ : Any = f'{dataset}-{pair}' SCREAMING_SNAKE_CASE_ : int = Path(snake_case_ ) save_dir.mkdir(exist_ok=snake_case_ ) for split in ds.keys(): print(f'Splitting {split} with {ds[split].num_rows} records' ) # to save to val.source, val.target like summary datasets SCREAMING_SNAKE_CASE_ : List[Any] = '''val''' if split == '''validation''' else split SCREAMING_SNAKE_CASE_ : Optional[int] = save_dir.joinpath(f'{fn}.source' ) SCREAMING_SNAKE_CASE_ : Optional[Any] = save_dir.joinpath(f'{fn}.target' ) SCREAMING_SNAKE_CASE_ : str = src_path.open('''w+''' ) SCREAMING_SNAKE_CASE_ : int = tgt_path.open('''w+''' ) # reader is the bottleneck so writing one record at a time doesn't slow things down for x in tqdm(ds[split] ): SCREAMING_SNAKE_CASE_ : Optional[int] = x['''translation'''] src_fp.write(ex[src_lang] + '''\n''' ) tgt_fp.write(ex[tgt_lang] + '''\n''' ) print(f'Saved {dataset} dataset to {save_dir}' ) if __name__ == "__main__": fire.Fire(download_wmt_dataset)
368
"""simple docstring""" import argparse import os import re import packaging.version UpperCAmelCase_ : Any = """examples/""" UpperCAmelCase_ : Optional[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"""), } UpperCAmelCase_ : List[Any] = { """init""": """src/transformers/__init__.py""", """setup""": """setup.py""", } UpperCAmelCase_ : Optional[int] = """README.md""" def _A (__a , __a , __a ) -> int: """simple docstring""" with open(__a , '''r''' , encoding='''utf-8''' , newline='''\n''' ) as f: SCREAMING_SNAKE_CASE_ : Optional[Any] = f.read() SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : List[Any] = REPLACE_PATTERNS[pattern] SCREAMING_SNAKE_CASE_ : Optional[int] = replace.replace('''VERSION''' , __a ) SCREAMING_SNAKE_CASE_ : Tuple = re_pattern.sub(__a , __a ) with open(__a , '''w''' , encoding='''utf-8''' , newline='''\n''' ) as f: f.write(__a ) def _A (__a ) -> int: """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 _A (__a , __a=False ) -> List[str]: """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 _A () -> int: """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[Any] = '''🤗 Transformers currently provides the following architectures''' SCREAMING_SNAKE_CASE_ : Optional[int] = '''1. Want to contribute a new model?''' with open(__a , '''r''' , encoding='''utf-8''' , newline='''\n''' ) as f: SCREAMING_SNAKE_CASE_ : Tuple = f.readlines() # Find the start of the list. SCREAMING_SNAKE_CASE_ : Tuple = 0 while not lines[start_index].startswith(_start_prompt ): start_index += 1 start_index += 1 SCREAMING_SNAKE_CASE_ : Dict = start_index # Update the lines in the model list. while not lines[index].startswith(_end_prompt ): if lines[index].startswith('''1.''' ): SCREAMING_SNAKE_CASE_ : List[Any] = 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 _A () -> List[str]: """simple docstring""" with open(REPLACE_FILES['''init'''] , '''r''' ) as f: SCREAMING_SNAKE_CASE_ : Any = f.read() SCREAMING_SNAKE_CASE_ : Dict = REPLACE_PATTERNS['''init'''][0].search(__a ).groups()[0] return packaging.version.parse(__a ) def _A (__a=False ) -> List[Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Tuple = 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: SCREAMING_SNAKE_CASE_ : List[Any] = default_version.base_version elif patch: SCREAMING_SNAKE_CASE_ : int = f'{default_version.major}.{default_version.minor}.{default_version.micro + 1}' else: SCREAMING_SNAKE_CASE_ : Any = f'{default_version.major}.{default_version.minor + 1}.0' # Now let's ask nicely if that's the right one. SCREAMING_SNAKE_CASE_ : int = input(f'Which version are you releasing? [{default_version}]' ) if len(__a ) == 0: SCREAMING_SNAKE_CASE_ : Optional[Any] = 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 _A () -> Any: """simple docstring""" SCREAMING_SNAKE_CASE_ : Any = get_version() SCREAMING_SNAKE_CASE_ : Any = f'{current_version.major}.{current_version.minor + 1}.0.dev0' SCREAMING_SNAKE_CASE_ : Union[str, Any] = current_version.base_version # Check with the user we got that right. SCREAMING_SNAKE_CASE_ : int = input(f'Which version are we developing now? [{dev_version}]' ) if len(__a ) == 0: SCREAMING_SNAKE_CASE_ : Optional[int] = 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__": UpperCAmelCase_ : Optional[int] = argparse.ArgumentParser() parser.add_argument("""--post_release""", action="""store_true""", help="""Whether this is pre or post release.""") parser.add_argument("""--patch""", action="""store_true""", help="""Whether or not this is a patch release.""") UpperCAmelCase_ : 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()
318
0
"""simple docstring""" import argparse import json from pathlib import Path import requests import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import ( BertTokenizer, ViltConfig, ViltForImageAndTextRetrieval, ViltForImagesAndTextClassification, ViltForMaskedLM, ViltForQuestionAnswering, ViltImageProcessor, ViltProcessor, ) from transformers.utils import logging logging.set_verbosity_info() UpperCAmelCase_ : str = logging.get_logger(__name__) def _A (__a , __a=False , __a=False , __a=False ) -> Optional[int]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Dict = [] for i in range(config.num_hidden_layers ): # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms rename_keys.append((f'transformer.blocks.{i}.norm1.weight', f'vilt.encoder.layer.{i}.layernorm_before.weight') ) rename_keys.append((f'transformer.blocks.{i}.norm1.bias', f'vilt.encoder.layer.{i}.layernorm_before.bias') ) rename_keys.append( (f'transformer.blocks.{i}.attn.proj.weight', f'vilt.encoder.layer.{i}.attention.output.dense.weight') ) rename_keys.append( (f'transformer.blocks.{i}.attn.proj.bias', f'vilt.encoder.layer.{i}.attention.output.dense.bias') ) rename_keys.append((f'transformer.blocks.{i}.norm2.weight', f'vilt.encoder.layer.{i}.layernorm_after.weight') ) rename_keys.append((f'transformer.blocks.{i}.norm2.bias', f'vilt.encoder.layer.{i}.layernorm_after.bias') ) rename_keys.append( (f'transformer.blocks.{i}.mlp.fc1.weight', f'vilt.encoder.layer.{i}.intermediate.dense.weight') ) rename_keys.append((f'transformer.blocks.{i}.mlp.fc1.bias', f'vilt.encoder.layer.{i}.intermediate.dense.bias') ) rename_keys.append((f'transformer.blocks.{i}.mlp.fc2.weight', f'vilt.encoder.layer.{i}.output.dense.weight') ) rename_keys.append((f'transformer.blocks.{i}.mlp.fc2.bias', f'vilt.encoder.layer.{i}.output.dense.bias') ) # embeddings rename_keys.extend( [ # text embeddings ('''text_embeddings.word_embeddings.weight''', '''vilt.embeddings.text_embeddings.word_embeddings.weight'''), ( '''text_embeddings.position_embeddings.weight''', '''vilt.embeddings.text_embeddings.position_embeddings.weight''', ), ('''text_embeddings.position_ids''', '''vilt.embeddings.text_embeddings.position_ids'''), ( '''text_embeddings.token_type_embeddings.weight''', '''vilt.embeddings.text_embeddings.token_type_embeddings.weight''', ), ('''text_embeddings.LayerNorm.weight''', '''vilt.embeddings.text_embeddings.LayerNorm.weight'''), ('''text_embeddings.LayerNorm.bias''', '''vilt.embeddings.text_embeddings.LayerNorm.bias'''), # patch embeddings ('''transformer.cls_token''', '''vilt.embeddings.cls_token'''), ('''transformer.patch_embed.proj.weight''', '''vilt.embeddings.patch_embeddings.projection.weight'''), ('''transformer.patch_embed.proj.bias''', '''vilt.embeddings.patch_embeddings.projection.bias'''), ('''transformer.pos_embed''', '''vilt.embeddings.position_embeddings'''), # token type embeddings ('''token_type_embeddings.weight''', '''vilt.embeddings.token_type_embeddings.weight'''), ] ) # final layernorm + pooler rename_keys.extend( [ ('''transformer.norm.weight''', '''vilt.layernorm.weight'''), ('''transformer.norm.bias''', '''vilt.layernorm.bias'''), ('''pooler.dense.weight''', '''vilt.pooler.dense.weight'''), ('''pooler.dense.bias''', '''vilt.pooler.dense.bias'''), ] ) # classifier head(s) if vqa_model: # classification head rename_keys.extend( [ ('''vqa_classifier.0.weight''', '''classifier.0.weight'''), ('''vqa_classifier.0.bias''', '''classifier.0.bias'''), ('''vqa_classifier.1.weight''', '''classifier.1.weight'''), ('''vqa_classifier.1.bias''', '''classifier.1.bias'''), ('''vqa_classifier.3.weight''', '''classifier.3.weight'''), ('''vqa_classifier.3.bias''', '''classifier.3.bias'''), ] ) elif nlvr_model: # classification head rename_keys.extend( [ ('''nlvr2_classifier.0.weight''', '''classifier.0.weight'''), ('''nlvr2_classifier.0.bias''', '''classifier.0.bias'''), ('''nlvr2_classifier.1.weight''', '''classifier.1.weight'''), ('''nlvr2_classifier.1.bias''', '''classifier.1.bias'''), ('''nlvr2_classifier.3.weight''', '''classifier.3.weight'''), ('''nlvr2_classifier.3.bias''', '''classifier.3.bias'''), ] ) else: pass return rename_keys def _A (__a , __a ) -> Tuple: """simple docstring""" for i in range(config.num_hidden_layers ): SCREAMING_SNAKE_CASE_ : List[str] = 'vilt.' # read in weights + bias of input projection layer (in timm, this is a single matrix + bias) SCREAMING_SNAKE_CASE_ : List[Any] = state_dict.pop(f'transformer.blocks.{i}.attn.qkv.weight' ) SCREAMING_SNAKE_CASE_ : List[str] = state_dict.pop(f'transformer.blocks.{i}.attn.qkv.bias' ) # next, add query, keys and values (in that order) to the state dict SCREAMING_SNAKE_CASE_ : Tuple = in_proj_weight[ : config.hidden_size, : ] SCREAMING_SNAKE_CASE_ : Tuple = in_proj_bias[: config.hidden_size] SCREAMING_SNAKE_CASE_ : List[Any] = in_proj_weight[ config.hidden_size : config.hidden_size * 2, : ] SCREAMING_SNAKE_CASE_ : str = in_proj_bias[ config.hidden_size : config.hidden_size * 2 ] SCREAMING_SNAKE_CASE_ : Optional[int] = in_proj_weight[ -config.hidden_size :, : ] SCREAMING_SNAKE_CASE_ : List[Any] = in_proj_bias[-config.hidden_size :] def _A (__a ) -> List[str]: """simple docstring""" SCREAMING_SNAKE_CASE_ : int = ['head.weight', 'head.bias'] for k in ignore_keys: state_dict.pop(lowerCAmelCase_ , lowerCAmelCase_ ) def _A (__a , __a , __a ) -> Optional[int]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Tuple = dct.pop(lowerCAmelCase_ ) SCREAMING_SNAKE_CASE_ : int = val @torch.no_grad() def _A (__a , __a ) -> Tuple: """simple docstring""" SCREAMING_SNAKE_CASE_ : int = ViltConfig(image_size=3_84 , patch_size=32 , tie_word_embeddings=lowerCAmelCase_ ) SCREAMING_SNAKE_CASE_ : Tuple = False SCREAMING_SNAKE_CASE_ : Any = False SCREAMING_SNAKE_CASE_ : Optional[Any] = False SCREAMING_SNAKE_CASE_ : int = False if "vqa" in checkpoint_url: SCREAMING_SNAKE_CASE_ : List[Any] = True SCREAMING_SNAKE_CASE_ : Any = 31_29 SCREAMING_SNAKE_CASE_ : List[str] = 'huggingface/label-files' SCREAMING_SNAKE_CASE_ : str = 'vqa2-id2label.json' SCREAMING_SNAKE_CASE_ : int = json.load(open(hf_hub_download(lowerCAmelCase_ , lowerCAmelCase_ , repo_type='''dataset''' ) , '''r''' ) ) SCREAMING_SNAKE_CASE_ : Dict = {int(lowerCAmelCase_ ): v for k, v in idalabel.items()} SCREAMING_SNAKE_CASE_ : Tuple = idalabel SCREAMING_SNAKE_CASE_ : Tuple = {v: k for k, v in idalabel.items()} SCREAMING_SNAKE_CASE_ : Tuple = ViltForQuestionAnswering(lowerCAmelCase_ ) elif "nlvr" in checkpoint_url: SCREAMING_SNAKE_CASE_ : Any = True SCREAMING_SNAKE_CASE_ : int = 2 SCREAMING_SNAKE_CASE_ : Optional[Any] = {0: 'False', 1: 'True'} SCREAMING_SNAKE_CASE_ : Dict = {v: k for k, v in config.idalabel.items()} SCREAMING_SNAKE_CASE_ : Union[str, Any] = 3 SCREAMING_SNAKE_CASE_ : List[Any] = ViltForImagesAndTextClassification(lowerCAmelCase_ ) elif "irtr" in checkpoint_url: SCREAMING_SNAKE_CASE_ : Tuple = True SCREAMING_SNAKE_CASE_ : Any = ViltForImageAndTextRetrieval(lowerCAmelCase_ ) elif "mlm_itm" in checkpoint_url: SCREAMING_SNAKE_CASE_ : Optional[int] = True SCREAMING_SNAKE_CASE_ : Tuple = ViltForMaskedLM(lowerCAmelCase_ ) else: raise ValueError('''Unknown model type''' ) # load state_dict of original model, remove and rename some keys SCREAMING_SNAKE_CASE_ : Dict = torch.hub.load_state_dict_from_url(lowerCAmelCase_ , map_location='''cpu''' )['state_dict'] SCREAMING_SNAKE_CASE_ : List[Any] = create_rename_keys(lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ ) for src, dest in rename_keys: rename_key(lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ ) read_in_q_k_v(lowerCAmelCase_ , lowerCAmelCase_ ) if mlm_model or irtr_model: SCREAMING_SNAKE_CASE_ : List[Any] = ['itm_score.fc.weight', 'itm_score.fc.bias'] for k in ignore_keys: state_dict.pop(lowerCAmelCase_ , lowerCAmelCase_ ) # load state dict into HuggingFace model model.eval() if mlm_model: SCREAMING_SNAKE_CASE_ : Tuple = model.load_state_dict(lowerCAmelCase_ , strict=lowerCAmelCase_ ) assert missing_keys == ["mlm_score.decoder.bias"] else: model.load_state_dict(lowerCAmelCase_ ) # Define processor SCREAMING_SNAKE_CASE_ : Union[str, Any] = ViltImageProcessor(size=3_84 ) SCREAMING_SNAKE_CASE_ : Optional[int] = BertTokenizer.from_pretrained('''bert-base-uncased''' ) SCREAMING_SNAKE_CASE_ : Optional[Any] = ViltProcessor(lowerCAmelCase_ , lowerCAmelCase_ ) # Forward pass on example inputs (image + text) if nlvr_model: SCREAMING_SNAKE_CASE_ : List[str] = Image.open(requests.get('''https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg''' , stream=lowerCAmelCase_ ).raw ) SCREAMING_SNAKE_CASE_ : str = Image.open(requests.get('''https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg''' , stream=lowerCAmelCase_ ).raw ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = ( 'The left image contains twice the number of dogs as the right image, and at least two dogs in total are' ' standing.' ) SCREAMING_SNAKE_CASE_ : Optional[Any] = processor(lowerCAmelCase_ , lowerCAmelCase_ , return_tensors='''pt''' ) SCREAMING_SNAKE_CASE_ : List[str] = processor(lowerCAmelCase_ , lowerCAmelCase_ , return_tensors='''pt''' ) SCREAMING_SNAKE_CASE_ : Dict = model( input_ids=encoding_a.input_ids , pixel_values=encoding_a.pixel_values , pixel_values_a=encoding_a.pixel_values , ) else: SCREAMING_SNAKE_CASE_ : Union[str, Any] = Image.open(requests.get('''http://images.cocodataset.org/val2017/000000039769.jpg''' , stream=lowerCAmelCase_ ).raw ) if mlm_model: SCREAMING_SNAKE_CASE_ : List[Any] = 'a bunch of [MASK] laying on a [MASK].' else: SCREAMING_SNAKE_CASE_ : Tuple = 'How many cats are there?' SCREAMING_SNAKE_CASE_ : Union[str, Any] = processor(lowerCAmelCase_ , lowerCAmelCase_ , return_tensors='''pt''' ) SCREAMING_SNAKE_CASE_ : Tuple = model(**lowerCAmelCase_ ) # Verify outputs if mlm_model: SCREAMING_SNAKE_CASE_ : str = torch.Size([1, 11, 3_05_22] ) SCREAMING_SNAKE_CASE_ : Optional[Any] = torch.tensor([-12.50_61, -12.51_23, -12.51_74] ) assert outputs.logits.shape == expected_shape assert torch.allclose(outputs.logits[0, 0, :3] , lowerCAmelCase_ , atol=1e-4 ) # verify masked token prediction equals "cats" SCREAMING_SNAKE_CASE_ : Any = outputs.logits[0, 4, :].argmax(-1 ).item() assert tokenizer.decode([predicted_id] ) == "cats" elif vqa_model: SCREAMING_SNAKE_CASE_ : Optional[Any] = torch.Size([1, 31_29] ) SCREAMING_SNAKE_CASE_ : Dict = torch.tensor([-15.94_95, -18.14_72, -10.30_41] ) assert torch.allclose(outputs.logits[0, :3] , lowerCAmelCase_ , atol=1e-4 ) assert outputs.logits.shape == expected_shape assert torch.allclose(outputs.logits[0, 0, :3] , lowerCAmelCase_ , atol=1e-4 ) # verify vqa prediction equals "2" SCREAMING_SNAKE_CASE_ : str = outputs.logits.argmax(-1 ).item() assert model.config.idalabel[predicted_idx] == "2" elif nlvr_model: SCREAMING_SNAKE_CASE_ : Union[str, Any] = torch.Size([1, 2] ) SCREAMING_SNAKE_CASE_ : List[Any] = torch.tensor([-2.87_21, 2.12_91] ) assert torch.allclose(outputs.logits[0, :3] , lowerCAmelCase_ , atol=1e-4 ) assert outputs.logits.shape == expected_shape Path(lowerCAmelCase_ ).mkdir(exist_ok=lowerCAmelCase_ ) print(f'Saving model and processor to {pytorch_dump_folder_path}' ) model.save_pretrained(lowerCAmelCase_ ) processor.save_pretrained(lowerCAmelCase_ ) if __name__ == "__main__": UpperCAmelCase_ : Tuple = argparse.ArgumentParser() # Required parameters parser.add_argument( """--checkpoint_url""", default="""https://github.com/dandelin/ViLT/releases/download/200k/vilt_200k_mlm_itm.ckpt""", type=str, help="""URL of the checkpoint you\'d like to convert.""", ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory.""" ) UpperCAmelCase_ : str = parser.parse_args() convert_vilt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)
369
"""simple docstring""" from typing import Optional, Tuple import jax import jax.numpy as jnp from flax import linen as nn from flax.core.frozen_dict import FrozenDict from transformers import CLIPConfig, FlaxPreTrainedModel from transformers.models.clip.modeling_flax_clip import FlaxCLIPVisionModule def _A (__a , __a , __a=1e-12 ) -> List[Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Union[str, Any] = jnp.divide(emb_a.T , jnp.clip(jnp.linalg.norm(__a , axis=1 ) , a_min=__a ) ).T SCREAMING_SNAKE_CASE_ : List[Any] = jnp.divide(emb_a.T , jnp.clip(jnp.linalg.norm(__a , axis=1 ) , a_min=__a ) ).T return jnp.matmul(__a , norm_emb_a.T ) class lowerCAmelCase__ ( nn.Module ): '''simple docstring''' __UpperCamelCase = 42 __UpperCamelCase = jnp.floataa def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = FlaxCLIPVisionModule(self.config.vision_config) SCREAMING_SNAKE_CASE_ : Tuple = nn.Dense(self.config.projection_dim , use_bias=lowercase_ , dtype=self.dtype) SCREAMING_SNAKE_CASE_ : List[str] = self.param('''concept_embeds''' , jax.nn.initializers.ones , (17, self.config.projection_dim)) SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.param( '''special_care_embeds''' , jax.nn.initializers.ones , (3, self.config.projection_dim)) SCREAMING_SNAKE_CASE_ : Dict = self.param('''concept_embeds_weights''' , jax.nn.initializers.ones , (17,)) SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.param('''special_care_embeds_weights''' , jax.nn.initializers.ones , (3,)) def __call__( self : Optional[Any] , lowercase_ : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = self.vision_model(lowercase_)[1] SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.visual_projection(lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = jax_cosine_distance(lowercase_ , self.special_care_embeds) SCREAMING_SNAKE_CASE_ : List[str] = jax_cosine_distance(lowercase_ , self.concept_embeds) # increase this value to create a stronger `nfsw` filter # at the cost of increasing the possibility of filtering benign image inputs SCREAMING_SNAKE_CASE_ : Tuple = 0.0 SCREAMING_SNAKE_CASE_ : Dict = special_cos_dist - self.special_care_embeds_weights[None, :] + adjustment SCREAMING_SNAKE_CASE_ : Optional[int] = jnp.round(lowercase_ , 3) SCREAMING_SNAKE_CASE_ : List[Any] = jnp.any(special_scores > 0 , axis=1 , keepdims=lowercase_) # Use a lower threshold if an image has any special care concept SCREAMING_SNAKE_CASE_ : Dict = is_special_care * 0.01 SCREAMING_SNAKE_CASE_ : str = cos_dist - self.concept_embeds_weights[None, :] + special_adjustment SCREAMING_SNAKE_CASE_ : Any = jnp.round(lowercase_ , 3) SCREAMING_SNAKE_CASE_ : Dict = jnp.any(concept_scores > 0 , axis=1) return has_nsfw_concepts class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = CLIPConfig __UpperCamelCase = "clip_input" __UpperCamelCase = FlaxStableDiffusionSafetyCheckerModule def __init__( self : Union[str, Any] , lowercase_ : CLIPConfig , lowercase_ : Optional[Tuple] = None , lowercase_ : int = 0 , lowercase_ : jnp.dtype = jnp.floataa , lowercase_ : bool = True , **lowercase_ : Any , ): '''simple docstring''' if input_shape is None: SCREAMING_SNAKE_CASE_ : List[str] = (1, 224, 224, 3) SCREAMING_SNAKE_CASE_ : List[Any] = self.module_class(config=lowercase_ , dtype=lowercase_ , **lowercase_) super().__init__(lowercase_ , lowercase_ , input_shape=lowercase_ , seed=lowercase_ , dtype=lowercase_ , _do_init=_do_init) def _SCREAMING_SNAKE_CASE ( self : Tuple , lowercase_ : jax.random.KeyArray , lowercase_ : Tuple , lowercase_ : FrozenDict = None): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = jax.random.normal(lowercase_ , lowercase_) SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Union[str, Any] = jax.random.split(lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = {'''params''': params_rng, '''dropout''': dropout_rng} SCREAMING_SNAKE_CASE_ : List[Any] = self.module.init(lowercase_ , lowercase_)['''params'''] return random_params def __call__( self : List[Any] , lowercase_ : List[str] , lowercase_ : dict = None , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = jnp.transpose(lowercase_ , (0, 2, 3, 1)) return self.module.apply( {'''params''': params or self.params} , jnp.array(lowercase_ , dtype=jnp.floataa) , rngs={} , )
318
0
from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCAmelCase_ : Union[str, Any] = logging.get_logger(__name__) UpperCAmelCase_ : Optional[int] = { """MIT/ast-finetuned-audioset-10-10-0.4593""": ( """https://huggingface.co/MIT/ast-finetuned-audioset-10-10-0.4593/resolve/main/config.json""" ), } class lowerCAmelCase__ ( __snake_case ): '''simple docstring''' __UpperCamelCase = """audio-spectrogram-transformer""" def __init__( self : str , lowercase_ : Optional[Any]=768 , lowercase_ : Union[str, Any]=12 , lowercase_ : List[str]=12 , lowercase_ : Tuple=3072 , lowercase_ : Dict="gelu" , lowercase_ : Union[str, Any]=0.0 , lowercase_ : Any=0.0 , lowercase_ : Optional[Any]=0.02 , lowercase_ : Any=1e-12 , lowercase_ : Optional[int]=16 , lowercase_ : List[Any]=True , lowercase_ : Union[str, Any]=10 , lowercase_ : Dict=10 , lowercase_ : Optional[int]=1024 , lowercase_ : Optional[Any]=128 , **lowercase_ : int , ): '''simple docstring''' super().__init__(**UpperCamelCase__) SCREAMING_SNAKE_CASE_ : Tuple = hidden_size SCREAMING_SNAKE_CASE_ : Dict = num_hidden_layers SCREAMING_SNAKE_CASE_ : int = num_attention_heads SCREAMING_SNAKE_CASE_ : Optional[Any] = intermediate_size SCREAMING_SNAKE_CASE_ : Optional[Any] = hidden_act SCREAMING_SNAKE_CASE_ : Optional[Any] = hidden_dropout_prob SCREAMING_SNAKE_CASE_ : Union[str, Any] = attention_probs_dropout_prob SCREAMING_SNAKE_CASE_ : Optional[int] = initializer_range SCREAMING_SNAKE_CASE_ : Optional[int] = layer_norm_eps SCREAMING_SNAKE_CASE_ : Optional[Any] = patch_size SCREAMING_SNAKE_CASE_ : Optional[Any] = qkv_bias SCREAMING_SNAKE_CASE_ : Any = frequency_stride SCREAMING_SNAKE_CASE_ : Union[str, Any] = time_stride SCREAMING_SNAKE_CASE_ : Union[str, Any] = max_length SCREAMING_SNAKE_CASE_ : List[str] = num_mel_bins
370
"""simple docstring""" from __future__ import annotations import queue class lowerCAmelCase__ : '''simple docstring''' def __init__( self : Tuple , lowercase_ : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = data SCREAMING_SNAKE_CASE_ : Tuple = None SCREAMING_SNAKE_CASE_ : Dict = None def _A () -> TreeNode: """simple docstring""" print('''\n********Press N to stop entering at any point of time********\n''' ) SCREAMING_SNAKE_CASE_ : List[Any] = input('''Enter the value of the root node: ''' ).strip().lower() SCREAMING_SNAKE_CASE_ : queue.Queue = queue.Queue() SCREAMING_SNAKE_CASE_ : Union[str, Any] = TreeNode(int(__a ) ) q.put(__a ) while not q.empty(): SCREAMING_SNAKE_CASE_ : Optional[int] = q.get() SCREAMING_SNAKE_CASE_ : List[str] = f'Enter the left node of {node_found.data}: ' SCREAMING_SNAKE_CASE_ : Optional[int] = input(__a ).strip().lower() or '''n''' if check == "n": return tree_node SCREAMING_SNAKE_CASE_ : List[str] = TreeNode(int(__a ) ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = left_node q.put(__a ) SCREAMING_SNAKE_CASE_ : str = f'Enter the right node of {node_found.data}: ' SCREAMING_SNAKE_CASE_ : str = input(__a ).strip().lower() or '''n''' if check == "n": return tree_node SCREAMING_SNAKE_CASE_ : Any = TreeNode(int(__a ) ) SCREAMING_SNAKE_CASE_ : int = right_node q.put(__a ) raise def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return print(node.data , end=''',''' ) pre_order(node.left ) pre_order(node.right ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return in_order(node.left ) print(node.data , end=''',''' ) in_order(node.right ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return post_order(node.left ) post_order(node.right ) print(node.data , end=''',''' ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ : queue.Queue = queue.Queue() q.put(__a ) while not q.empty(): SCREAMING_SNAKE_CASE_ : Tuple = q.get() print(node_dequeued.data , end=''',''' ) if node_dequeued.left: q.put(node_dequeued.left ) if node_dequeued.right: q.put(node_dequeued.right ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ : queue.Queue = queue.Queue() q.put(__a ) while not q.empty(): SCREAMING_SNAKE_CASE_ : str = [] while not q.empty(): SCREAMING_SNAKE_CASE_ : List[str] = q.get() print(node_dequeued.data , end=''',''' ) if node_dequeued.left: list_.append(node_dequeued.left ) if node_dequeued.right: list_.append(node_dequeued.right ) print() for node in list_: q.put(__a ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ : list[TreeNode] = [] SCREAMING_SNAKE_CASE_ : Union[str, Any] = node while n or stack: while n: # start from root node, find its left child print(n.data , end=''',''' ) stack.append(__a ) SCREAMING_SNAKE_CASE_ : Optional[Any] = n.left # end of while means current node doesn't have left child SCREAMING_SNAKE_CASE_ : Tuple = stack.pop() # start to traverse its right child SCREAMING_SNAKE_CASE_ : str = n.right def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ : list[TreeNode] = [] SCREAMING_SNAKE_CASE_ : Any = node while n or stack: while n: stack.append(__a ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = n.left SCREAMING_SNAKE_CASE_ : Any = stack.pop() print(n.data , end=''',''' ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = n.right def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Any = [], [] SCREAMING_SNAKE_CASE_ : List[Any] = node stacka.append(__a ) while stacka: # to find the reversed order of post order, store it in stack2 SCREAMING_SNAKE_CASE_ : List[str] = stacka.pop() if n.left: stacka.append(n.left ) if n.right: stacka.append(n.right ) stacka.append(__a ) while stacka: # pop up from stack2 will be the post order print(stacka.pop().data , end=''',''' ) def _A (__a = "" , __a=50 , __a="*" ) -> str: """simple docstring""" if not s: return "\n" + width * char SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Dict = divmod(width - len(__a ) - 2 , 2 ) return f'{left * char} {s} {(left + extra) * char}' if __name__ == "__main__": import doctest doctest.testmod() print(prompt("""Binary Tree Traversals""")) UpperCAmelCase_ : TreeNode = build_tree() print(prompt("""Pre Order Traversal""")) pre_order(node) print(prompt() + """\n""") print(prompt("""In Order Traversal""")) in_order(node) print(prompt() + """\n""") print(prompt("""Post Order Traversal""")) post_order(node) print(prompt() + """\n""") print(prompt("""Level Order Traversal""")) level_order(node) print(prompt() + """\n""") print(prompt("""Actual Level Order Traversal""")) level_order_actual(node) print("""*""" * 50 + """\n""") print(prompt("""Pre Order Traversal - Iteration Version""")) pre_order_iter(node) print(prompt() + """\n""") print(prompt("""In Order Traversal - Iteration Version""")) in_order_iter(node) print(prompt() + """\n""") print(prompt("""Post Order Traversal - Iteration Version""")) post_order_iter(node) print(prompt())
318
0
"""simple docstring""" import re from pathlib import Path from unittest import TestCase import pytest @pytest.mark.integration class lowerCAmelCase__ ( lowerCamelCase_ ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : Union[str, Any] , lowercase_ : str): '''simple docstring''' with open(__snake_case , encoding='''utf-8''') as input_file: SCREAMING_SNAKE_CASE_ : str = re.compile(r'''(?!.*\b(?:encoding|rb|w|wb|w+|wb+|ab|ab+)\b)(?<=\s)(open)\((.*)\)''') SCREAMING_SNAKE_CASE_ : List[str] = input_file.read() SCREAMING_SNAKE_CASE_ : List[Any] = regexp.search(__snake_case) return match def _SCREAMING_SNAKE_CASE ( self : List[str] , lowercase_ : str): '''simple docstring''' with open(__snake_case , encoding='''utf-8''') as input_file: SCREAMING_SNAKE_CASE_ : List[str] = re.compile(r'''#[^\r\n]*print\(|\"[^\r\n]*print\(|\"\"\".*?print\(.*?\"\"\"|(print\()''' , re.DOTALL) SCREAMING_SNAKE_CASE_ : Any = input_file.read() # use `re.finditer` to handle the case where the ignored groups would be matched first by `re.search` SCREAMING_SNAKE_CASE_ : Dict = regexp.finditer(__snake_case) SCREAMING_SNAKE_CASE_ : int = [match for match in matches if match is not None and match.group(1) is not None] return matches[0] if matches else None def _SCREAMING_SNAKE_CASE ( self : Any): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = Path('''./datasets''') SCREAMING_SNAKE_CASE_ : str = list(dataset_paths.absolute().glob('''**/*.py''')) for dataset in dataset_files: if self._no_encoding_on_file_open(str(__snake_case)): raise AssertionError(F'open(...) must use utf-8 encoding in {dataset}') def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = Path('''./datasets''') SCREAMING_SNAKE_CASE_ : str = list(dataset_paths.absolute().glob('''**/*.py''')) for dataset in dataset_files: if self._no_print_statements(str(__snake_case)): raise AssertionError(F'print statement found in {dataset}. Use datasets.logger/logging instead.')
371
"""simple docstring""" import random import unittest import numpy as np import torch from diffusers import ( DPMSolverMultistepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, LMSDiscreteScheduler, OnnxStableDiffusionUpscalePipeline, PNDMScheduler, ) from diffusers.utils import floats_tensor from diffusers.utils.testing_utils import ( is_onnx_available, load_image, nightly, require_onnxruntime, require_torch_gpu, ) from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin if is_onnx_available(): import onnxruntime as ort class lowerCAmelCase__ ( UpperCAmelCase__ , unittest.TestCase ): '''simple docstring''' __UpperCamelCase = "ssube/stable-diffusion-x4-upscaler-onnx" def _SCREAMING_SNAKE_CASE ( self : Optional[int] , lowercase_ : Union[str, Any]=0): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = floats_tensor((1, 3, 128, 128) , rng=random.Random(lowercase_)) SCREAMING_SNAKE_CASE_ : List[str] = torch.manual_seed(lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = { '''prompt''': '''A painting of a squirrel eating a burger''', '''image''': image, '''generator''': generator, '''num_inference_steps''': 3, '''guidance_scale''': 7.5, '''output_type''': '''numpy''', } return inputs def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''') pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : Tuple = self.get_dummy_inputs() SCREAMING_SNAKE_CASE_ : Union[str, Any] = pipe(**lowercase_).images SCREAMING_SNAKE_CASE_ : Dict = image[0, -3:, -3:, -1].flatten() # started as 128, should now be 512 assert image.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : Any = np.array( [0.6_97_47_82, 0.68_90_20_93, 0.70_13_58_85, 0.7_58_36_18, 0.7_80_45_45, 0.7_85_49_12, 0.78_66_74_26, 0.78_74_38_63, 0.78_07_02_23]) assert np.abs(image_slice - expected_slice).max() < 1e-1 def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''') SCREAMING_SNAKE_CASE_ : Optional[int] = PNDMScheduler.from_config(pipe.scheduler.config , skip_prk_steps=lowercase_) pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : Any = self.get_dummy_inputs() SCREAMING_SNAKE_CASE_ : Optional[Any] = pipe(**lowercase_).images SCREAMING_SNAKE_CASE_ : int = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : Any = np.array( [0.6_89_88_92, 0.59_24_05_56, 0.52_49_95_27, 0.58_86_62_15, 0.52_25_82_35, 0.52_57_27_15, 0.62_41_44_73, 0.6_17_43_87, 0.6_21_49_64]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-1 def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''') SCREAMING_SNAKE_CASE_ : Union[str, Any] = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = self.get_dummy_inputs() SCREAMING_SNAKE_CASE_ : Tuple = pipe(**lowercase_).images SCREAMING_SNAKE_CASE_ : Union[str, Any] = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : Tuple = np.array( [0.7_65_92_78, 0.76_43_76_64, 0.75_57_91_07, 0.7_69_11_16, 0.77_66_69_86, 0.7_72_76_72, 0.7_75_86_64, 0.7_81_22_26, 0.76_94_25_15]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-1 def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''') SCREAMING_SNAKE_CASE_ : List[Any] = EulerDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : Any = self.get_dummy_inputs() SCREAMING_SNAKE_CASE_ : Optional[Any] = pipe(**lowercase_).images SCREAMING_SNAKE_CASE_ : Optional[int] = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : Optional[Any] = np.array( [0.6_97_47_82, 0.68_90_20_93, 0.70_13_58_85, 0.7_58_36_18, 0.7_80_45_45, 0.7_85_49_12, 0.78_66_74_26, 0.78_74_38_63, 0.78_07_02_23]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-1 def _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''') SCREAMING_SNAKE_CASE_ : int = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = self.get_dummy_inputs() SCREAMING_SNAKE_CASE_ : Optional[int] = pipe(**lowercase_).images SCREAMING_SNAKE_CASE_ : str = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : int = np.array( [0.77_42_44_96, 0.77_36_01, 0.7_64_52_88, 0.7_76_95_98, 0.7_77_27_39, 0.7_73_86_88, 0.78_18_72_33, 0.77_87_95_84, 0.76_70_43]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-1 @nightly @require_onnxruntime @require_torch_gpu class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' @property def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' return ( "CUDAExecutionProvider", { "gpu_mem_limit": "15000000000", # 15GB "arena_extend_strategy": "kSameAsRequested", }, ) @property def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = ort.SessionOptions() SCREAMING_SNAKE_CASE_ : Optional[int] = False return options def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = load_image( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/img2img/sketch-mountains-input.jpg''') SCREAMING_SNAKE_CASE_ : Tuple = init_image.resize((128, 128)) # using the PNDM scheduler by default SCREAMING_SNAKE_CASE_ : List[str] = OnnxStableDiffusionUpscalePipeline.from_pretrained( '''ssube/stable-diffusion-x4-upscaler-onnx''' , provider=self.gpu_provider , sess_options=self.gpu_options , ) pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : Union[str, Any] = '''A fantasy landscape, trending on artstation''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = torch.manual_seed(0) SCREAMING_SNAKE_CASE_ : List[Any] = pipe( prompt=lowercase_ , image=lowercase_ , guidance_scale=7.5 , num_inference_steps=10 , generator=lowercase_ , output_type='''np''' , ) SCREAMING_SNAKE_CASE_ : Optional[int] = output.images SCREAMING_SNAKE_CASE_ : Optional[int] = images[0, 255:258, 383:386, -1] assert images.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : int = np.array([0.48_83, 0.49_47, 0.49_80, 0.49_75, 0.49_82, 0.49_80, 0.50_00, 0.50_06, 0.49_72]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2e-2 def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = load_image( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/img2img/sketch-mountains-input.jpg''') SCREAMING_SNAKE_CASE_ : Tuple = init_image.resize((128, 128)) SCREAMING_SNAKE_CASE_ : Tuple = LMSDiscreteScheduler.from_pretrained( '''ssube/stable-diffusion-x4-upscaler-onnx''' , subfolder='''scheduler''') SCREAMING_SNAKE_CASE_ : str = OnnxStableDiffusionUpscalePipeline.from_pretrained( '''ssube/stable-diffusion-x4-upscaler-onnx''' , scheduler=lowercase_ , provider=self.gpu_provider , sess_options=self.gpu_options , ) pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : int = '''A fantasy landscape, trending on artstation''' SCREAMING_SNAKE_CASE_ : List[Any] = torch.manual_seed(0) SCREAMING_SNAKE_CASE_ : int = pipe( prompt=lowercase_ , image=lowercase_ , guidance_scale=7.5 , num_inference_steps=20 , generator=lowercase_ , output_type='''np''' , ) SCREAMING_SNAKE_CASE_ : Optional[int] = output.images SCREAMING_SNAKE_CASE_ : Dict = images[0, 255:258, 383:386, -1] assert images.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : List[str] = np.array( [0.50_17_37_53, 0.50_22_33_56, 0.50_20_39, 0.50_23_30_36, 0.5_02_37_25, 0.5_02_26_01, 0.5_01_87_58, 0.50_23_40_85, 0.50_24_15_66]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2e-2
318
0
"""simple docstring""" from __future__ import annotations import queue class lowerCAmelCase__ : '''simple docstring''' def __init__( self : Tuple , lowercase_ : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = data SCREAMING_SNAKE_CASE_ : Tuple = None SCREAMING_SNAKE_CASE_ : Dict = None def _A () -> TreeNode: """simple docstring""" print('''\n********Press N to stop entering at any point of time********\n''' ) SCREAMING_SNAKE_CASE_ : List[Any] = input('''Enter the value of the root node: ''' ).strip().lower() SCREAMING_SNAKE_CASE_ : queue.Queue = queue.Queue() SCREAMING_SNAKE_CASE_ : Union[str, Any] = TreeNode(int(__a ) ) q.put(__a ) while not q.empty(): SCREAMING_SNAKE_CASE_ : Optional[int] = q.get() SCREAMING_SNAKE_CASE_ : List[str] = f'Enter the left node of {node_found.data}: ' SCREAMING_SNAKE_CASE_ : Optional[int] = input(__a ).strip().lower() or '''n''' if check == "n": return tree_node SCREAMING_SNAKE_CASE_ : List[str] = TreeNode(int(__a ) ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = left_node q.put(__a ) SCREAMING_SNAKE_CASE_ : str = f'Enter the right node of {node_found.data}: ' SCREAMING_SNAKE_CASE_ : str = input(__a ).strip().lower() or '''n''' if check == "n": return tree_node SCREAMING_SNAKE_CASE_ : Any = TreeNode(int(__a ) ) SCREAMING_SNAKE_CASE_ : int = right_node q.put(__a ) raise def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return print(node.data , end=''',''' ) pre_order(node.left ) pre_order(node.right ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return in_order(node.left ) print(node.data , end=''',''' ) in_order(node.right ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return post_order(node.left ) post_order(node.right ) print(node.data , end=''',''' ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ : queue.Queue = queue.Queue() q.put(__a ) while not q.empty(): SCREAMING_SNAKE_CASE_ : Tuple = q.get() print(node_dequeued.data , end=''',''' ) if node_dequeued.left: q.put(node_dequeued.left ) if node_dequeued.right: q.put(node_dequeued.right ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ : queue.Queue = queue.Queue() q.put(__a ) while not q.empty(): SCREAMING_SNAKE_CASE_ : str = [] while not q.empty(): SCREAMING_SNAKE_CASE_ : List[str] = q.get() print(node_dequeued.data , end=''',''' ) if node_dequeued.left: list_.append(node_dequeued.left ) if node_dequeued.right: list_.append(node_dequeued.right ) print() for node in list_: q.put(__a ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ : list[TreeNode] = [] SCREAMING_SNAKE_CASE_ : Union[str, Any] = node while n or stack: while n: # start from root node, find its left child print(n.data , end=''',''' ) stack.append(__a ) SCREAMING_SNAKE_CASE_ : Optional[Any] = n.left # end of while means current node doesn't have left child SCREAMING_SNAKE_CASE_ : Tuple = stack.pop() # start to traverse its right child SCREAMING_SNAKE_CASE_ : str = n.right def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ : list[TreeNode] = [] SCREAMING_SNAKE_CASE_ : Any = node while n or stack: while n: stack.append(__a ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = n.left SCREAMING_SNAKE_CASE_ : Any = stack.pop() print(n.data , end=''',''' ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = n.right def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ : Any = [], [] SCREAMING_SNAKE_CASE_ : List[Any] = node stacka.append(__a ) while stacka: # to find the reversed order of post order, store it in stack2 SCREAMING_SNAKE_CASE_ : List[str] = stacka.pop() if n.left: stacka.append(n.left ) if n.right: stacka.append(n.right ) stacka.append(__a ) while stacka: # pop up from stack2 will be the post order print(stacka.pop().data , end=''',''' ) def _A (__a = "" , __a=50 , __a="*" ) -> str: """simple docstring""" if not s: return "\n" + width * char SCREAMING_SNAKE_CASE_ : Dict = divmod(width - len(__a ) - 2 , 2 ) return f'{left * char} {s} {(left + extra) * char}' if __name__ == "__main__": import doctest doctest.testmod() print(prompt("""Binary Tree Traversals""")) UpperCAmelCase_ : TreeNode = build_tree() print(prompt("""Pre Order Traversal""")) pre_order(node) print(prompt() + """\n""") print(prompt("""In Order Traversal""")) in_order(node) print(prompt() + """\n""") print(prompt("""Post Order Traversal""")) post_order(node) print(prompt() + """\n""") print(prompt("""Level Order Traversal""")) level_order(node) print(prompt() + """\n""") print(prompt("""Actual Level Order Traversal""")) level_order_actual(node) print("""*""" * 50 + """\n""") print(prompt("""Pre Order Traversal - Iteration Version""")) pre_order_iter(node) print(prompt() + """\n""") print(prompt("""In Order Traversal - Iteration Version""")) in_order_iter(node) print(prompt() + """\n""") print(prompt("""Post Order Traversal - Iteration Version""")) post_order_iter(node) print(prompt())
350
"""simple docstring""" from scipy.stats import pearsonr import datasets UpperCAmelCase_ : List[Any] = """ Pearson correlation coefficient and p-value for testing non-correlation. The Pearson correlation coefficient measures the linear relationship between two datasets. The calculation of the p-value relies on the assumption that each dataset is normally distributed. Like other correlation coefficients, this one varies between -1 and +1 with 0 implying no correlation. Correlations of -1 or +1 imply an exact linear relationship. Positive correlations imply that as x increases, so does y. Negative correlations imply that as x increases, y decreases. The p-value roughly indicates the probability of an uncorrelated system producing datasets that have a Pearson correlation at least as extreme as the one computed from these datasets. """ UpperCAmelCase_ : Optional[int] = """ Args: predictions (`list` of `int`): Predicted class labels, as returned by a model. references (`list` of `int`): Ground truth labels. return_pvalue (`boolean`): If `True`, returns the p-value, along with the correlation coefficient. If `False`, returns only the correlation coefficient. Defaults to `False`. Returns: pearsonr (`float`): Pearson correlation coefficient. Minimum possible value is -1. Maximum possible value is 1. Values of 1 and -1 indicate exact linear positive and negative relationships, respectively. A value of 0 implies no correlation. p-value (`float`): P-value, which roughly indicates the probability of an The p-value roughly indicates the probability of an uncorrelated system producing datasets that have a Pearson correlation at least as extreme as the one computed from these datasets. Minimum possible value is 0. Maximum possible value is 1. Higher values indicate higher probabilities. Examples: Example 1-A simple example using only predictions and references. >>> pearsonr_metric = datasets.load_metric(\"pearsonr\") >>> results = pearsonr_metric.compute(predictions=[10, 9, 2.5, 6, 4], references=[1, 2, 3, 4, 5]) >>> print(round(results['pearsonr'], 2)) -0.74 Example 2-The same as Example 1, but that also returns the `p-value`. >>> pearsonr_metric = datasets.load_metric(\"pearsonr\") >>> results = pearsonr_metric.compute(predictions=[10, 9, 2.5, 6, 4], references=[1, 2, 3, 4, 5], return_pvalue=True) >>> print(sorted(list(results.keys()))) ['p-value', 'pearsonr'] >>> print(round(results['pearsonr'], 2)) -0.74 >>> print(round(results['p-value'], 2)) 0.15 """ UpperCAmelCase_ : Tuple = """ @article{2020SciPy-NMeth, author = {Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E. and Haberland, Matt and Reddy, Tyler and Cournapeau, David and Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and Bright, Jonathan and {van der Walt}, St{\'e}fan J. and Brett, Matthew and Wilson, Joshua and Millman, K. Jarrod and Mayorov, Nikolay and Nelson, Andrew R. J. and Jones, Eric and Kern, Robert and Larson, Eric and Carey, C J and Polat, Ilhan and Feng, Yu and Moore, Eric W. and {VanderPlas}, Jake and Laxalde, Denis and Perktold, Josef and Cimrman, Robert and Henriksen, Ian and Quintero, E. A. and Harris, Charles R. and Archibald, Anne M. and Ribeiro, Antonio H. and Pedregosa, Fabian and {van Mulbregt}, Paul and {SciPy 1.0 Contributors}}, title = {{{SciPy} 1.0: Fundamental Algorithms for Scientific Computing in Python}}, journal = {Nature Methods}, year = {2020}, volume = {17}, pages = {261--272}, adsurl = {https://rdcu.be/b08Wh}, doi = {10.1038/s41592-019-0686-2}, } """ @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class lowerCAmelCase__ ( datasets.Metric ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { '''predictions''': datasets.Value('''float'''), '''references''': datasets.Value('''float'''), }) , reference_urls=['''https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.pearsonr.html'''] , ) def _SCREAMING_SNAKE_CASE ( self : List[Any] , lowercase_ : List[str] , lowercase_ : List[Any] , lowercase_ : Union[str, Any]=False): '''simple docstring''' if return_pvalue: SCREAMING_SNAKE_CASE_ : int = pearsonr(lowercase_ , lowercase_) return {"pearsonr": results[0], "p-value": results[1]} else: return {"pearsonr": float(pearsonr(lowercase_ , lowercase_)[0])}
318
0
"""simple docstring""" import argparse from .config import config_command_parser from .config_args import default_config_file, load_config_from_file # noqa: F401 from .default import default_command_parser from .update import update_command_parser def _A (__a=None ) -> Union[str, Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[int] = argparse.ArgumentParser(add_help=__a , allow_abbrev=__a ) # The main config parser SCREAMING_SNAKE_CASE_ : Optional[Any] = config_command_parser(__a ) # The subparser to add commands to SCREAMING_SNAKE_CASE_ : List[Any] = config_parser.add_subparsers(title='''subcommands''' , dest='''subcommand''' ) # Then add other parsers with the parent parser default_command_parser(__a , parents=[parent_parser] ) update_command_parser(__a , parents=[parent_parser] ) return config_parser def _A () -> List[Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : int = get_config_parser() SCREAMING_SNAKE_CASE_ : str = config_parser.parse_args() if not hasattr(__a , '''func''' ): config_parser.print_help() exit(1 ) # Run args.func(__a ) if __name__ == "__main__": main()
351
"""simple docstring""" import os from typing import Dict, List, Union import tensorflow as tf from keras_nlp.tokenizers import BytePairTokenizer from tensorflow_text import pad_model_inputs from .tokenization_gpta import GPTaTokenizer class lowerCAmelCase__ ( tf.keras.layers.Layer ): '''simple docstring''' def __init__( self : Any , lowercase_ : Dict[str, int] , lowercase_ : List[str] , lowercase_ : int = None , lowercase_ : int = None): '''simple docstring''' super().__init__() SCREAMING_SNAKE_CASE_ : str = pad_token_id SCREAMING_SNAKE_CASE_ : Optional[int] = max_length SCREAMING_SNAKE_CASE_ : Dict = vocab SCREAMING_SNAKE_CASE_ : Dict = merges SCREAMING_SNAKE_CASE_ : Union[str, Any] = BytePairTokenizer(lowercase_ , lowercase_ , sequence_length=lowercase_) @classmethod def _SCREAMING_SNAKE_CASE ( cls : Dict , lowercase_ : GPTaTokenizer , *lowercase_ : Optional[Any] , **lowercase_ : Tuple): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = [''' '''.join(lowercase_) for m in tokenizer.bpe_ranks.keys()] SCREAMING_SNAKE_CASE_ : str = tokenizer.get_vocab() return cls(lowercase_ , lowercase_ , *lowercase_ , **lowercase_) @classmethod def _SCREAMING_SNAKE_CASE ( cls : int , lowercase_ : Union[str, os.PathLike] , *lowercase_ : List[str] , **lowercase_ : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = GPTaTokenizer.from_pretrained(lowercase_ , *lowercase_ , **lowercase_) return cls.from_tokenizer(lowercase_ , *lowercase_ , **lowercase_) @classmethod def _SCREAMING_SNAKE_CASE ( cls : Dict , lowercase_ : List[Any]): '''simple docstring''' return cls(**lowercase_) def _SCREAMING_SNAKE_CASE ( self : Tuple): '''simple docstring''' return { "vocab": self.vocab, "merges": self.merges, "max_length": self.max_length, "pad_token_id": self.pad_token_id, } def _SCREAMING_SNAKE_CASE ( self : Any , lowercase_ : List[Any] , lowercase_ : int = None): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = self.tf_tokenizer(lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = tf.ones_like(lowercase_) if self.pad_token_id is not None: # pad the tokens up to max length SCREAMING_SNAKE_CASE_ : Union[str, Any] = max_length if max_length is not None else self.max_length if max_length is not None: SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : List[str] = pad_model_inputs( lowercase_ , max_seq_length=lowercase_ , pad_value=self.pad_token_id) return {"attention_mask": attention_mask, "input_ids": input_ids}
318
0
"""simple docstring""" from collections import OrderedDict from typing import Mapping from packaging import version from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging UpperCAmelCase_ : Dict = logging.get_logger(__name__) UpperCAmelCase_ : Optional[int] = { """google/vit-base-patch16-224""": """https://huggingface.co/vit-base-patch16-224/resolve/main/config.json""", # See all ViT models at https://huggingface.co/models?filter=vit } class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = "vit" def __init__( self : Any , lowercase_ : Union[str, Any]=768 , lowercase_ : str=12 , lowercase_ : Any=12 , lowercase_ : Optional[int]=3072 , lowercase_ : Any="gelu" , lowercase_ : Optional[int]=0.0 , lowercase_ : List[str]=0.0 , lowercase_ : int=0.02 , lowercase_ : int=1e-12 , lowercase_ : Dict=224 , lowercase_ : Any=16 , lowercase_ : Any=3 , lowercase_ : Optional[int]=True , lowercase_ : Optional[int]=16 , **lowercase_ : Dict , ): '''simple docstring''' super().__init__(**lowercase_) SCREAMING_SNAKE_CASE_ : List[Any] = hidden_size SCREAMING_SNAKE_CASE_ : Tuple = num_hidden_layers SCREAMING_SNAKE_CASE_ : List[Any] = num_attention_heads SCREAMING_SNAKE_CASE_ : List[Any] = intermediate_size SCREAMING_SNAKE_CASE_ : Any = hidden_act SCREAMING_SNAKE_CASE_ : int = hidden_dropout_prob SCREAMING_SNAKE_CASE_ : Dict = attention_probs_dropout_prob SCREAMING_SNAKE_CASE_ : str = initializer_range SCREAMING_SNAKE_CASE_ : Dict = layer_norm_eps SCREAMING_SNAKE_CASE_ : List[str] = image_size SCREAMING_SNAKE_CASE_ : Optional[Any] = patch_size SCREAMING_SNAKE_CASE_ : Any = num_channels SCREAMING_SNAKE_CASE_ : Union[str, Any] = qkv_bias SCREAMING_SNAKE_CASE_ : List[str] = encoder_stride class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = version.parse("1.11" ) @property def _SCREAMING_SNAKE_CASE ( self : Any): '''simple docstring''' return OrderedDict( [ ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}), ]) @property def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' return 1e-4
352
"""simple docstring""" import json import os import shutil import tempfile import unittest import numpy as np import pytest from transformers import BertTokenizer, BertTokenizerFast from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES from transformers.testing_utils import require_vision from transformers.utils import FEATURE_EXTRACTOR_NAME, is_vision_available if is_vision_available(): from PIL import Image from transformers import ChineseCLIPImageProcessor, ChineseCLIPProcessor @require_vision class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = tempfile.mkdtemp() SCREAMING_SNAKE_CASE_ : Union[str, Any] = [ '''[UNK]''', '''[CLS]''', '''[SEP]''', '''[PAD]''', '''[MASK]''', '''的''', '''价''', '''格''', '''是''', '''15''', '''便''', '''alex''', '''##andra''', ''',''', '''。''', '''-''', '''t''', '''shirt''', ] SCREAMING_SNAKE_CASE_ : int = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['''vocab_file''']) with open(self.vocab_file , '''w''' , encoding='''utf-8''') as vocab_writer: vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens])) SCREAMING_SNAKE_CASE_ : Dict = { '''do_resize''': True, '''size''': {'''height''': 224, '''width''': 224}, '''do_center_crop''': True, '''crop_size''': {'''height''': 18, '''width''': 18}, '''do_normalize''': True, '''image_mean''': [0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73], '''image_std''': [0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11], '''do_convert_rgb''': True, } SCREAMING_SNAKE_CASE_ : int = os.path.join(self.tmpdirname , lowercase_) with open(self.image_processor_file , '''w''' , encoding='''utf-8''') as fp: json.dump(lowercase_ , lowercase_) def _SCREAMING_SNAKE_CASE ( self : Optional[int] , **lowercase_ : str): '''simple docstring''' return BertTokenizer.from_pretrained(self.tmpdirname , **lowercase_) def _SCREAMING_SNAKE_CASE ( self : Tuple , **lowercase_ : List[Any]): '''simple docstring''' return BertTokenizerFast.from_pretrained(self.tmpdirname , **lowercase_) def _SCREAMING_SNAKE_CASE ( self : List[Any] , **lowercase_ : str): '''simple docstring''' return ChineseCLIPImageProcessor.from_pretrained(self.tmpdirname , **lowercase_) def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' shutil.rmtree(self.tmpdirname) def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = [np.random.randint(255 , size=(3, 30, 400) , dtype=np.uinta)] SCREAMING_SNAKE_CASE_ : Dict = [Image.fromarray(np.moveaxis(lowercase_ , 0 , -1)) for x in image_inputs] return image_inputs def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.get_rust_tokenizer() SCREAMING_SNAKE_CASE_ : Any = self.get_image_processor() SCREAMING_SNAKE_CASE_ : int = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) processor_slow.save_pretrained(self.tmpdirname) SCREAMING_SNAKE_CASE_ : Optional[int] = ChineseCLIPProcessor.from_pretrained(self.tmpdirname , use_fast=lowercase_) SCREAMING_SNAKE_CASE_ : Any = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) processor_fast.save_pretrained(self.tmpdirname) SCREAMING_SNAKE_CASE_ : int = ChineseCLIPProcessor.from_pretrained(self.tmpdirname) self.assertEqual(processor_slow.tokenizer.get_vocab() , tokenizer_slow.get_vocab()) self.assertEqual(processor_fast.tokenizer.get_vocab() , tokenizer_fast.get_vocab()) self.assertEqual(tokenizer_slow.get_vocab() , tokenizer_fast.get_vocab()) self.assertIsInstance(processor_slow.tokenizer , lowercase_) self.assertIsInstance(processor_fast.tokenizer , lowercase_) self.assertEqual(processor_slow.image_processor.to_json_string() , image_processor.to_json_string()) self.assertEqual(processor_fast.image_processor.to_json_string() , image_processor.to_json_string()) self.assertIsInstance(processor_slow.image_processor , lowercase_) self.assertIsInstance(processor_fast.image_processor , lowercase_) def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = ChineseCLIPProcessor(tokenizer=self.get_tokenizer() , image_processor=self.get_image_processor()) processor.save_pretrained(self.tmpdirname) SCREAMING_SNAKE_CASE_ : Optional[int] = self.get_tokenizer(cls_token='''(CLS)''' , sep_token='''(SEP)''') SCREAMING_SNAKE_CASE_ : Optional[int] = self.get_image_processor(do_normalize=lowercase_) SCREAMING_SNAKE_CASE_ : Tuple = ChineseCLIPProcessor.from_pretrained( self.tmpdirname , cls_token='''(CLS)''' , sep_token='''(SEP)''' , do_normalize=lowercase_) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab()) self.assertIsInstance(processor.tokenizer , lowercase_) self.assertEqual(processor.image_processor.to_json_string() , image_processor_add_kwargs.to_json_string()) self.assertIsInstance(processor.image_processor , lowercase_) def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = self.get_image_processor() SCREAMING_SNAKE_CASE_ : List[Any] = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : Tuple = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = self.prepare_image_inputs() SCREAMING_SNAKE_CASE_ : Any = image_processor(lowercase_ , return_tensors='''np''') SCREAMING_SNAKE_CASE_ : Union[str, Any] = processor(images=lowercase_ , return_tensors='''np''') for key in input_feat_extract.keys(): self.assertAlmostEqual(input_feat_extract[key].sum() , input_processor[key].sum() , delta=1e-2) def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = self.get_image_processor() SCREAMING_SNAKE_CASE_ : Any = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : str = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) SCREAMING_SNAKE_CASE_ : Dict = '''Alexandra,T-shirt的价格是15便士。''' SCREAMING_SNAKE_CASE_ : Optional[Any] = processor(text=lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = tokenizer(lowercase_) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key]) def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = self.get_image_processor() SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : int = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) SCREAMING_SNAKE_CASE_ : Union[str, Any] = '''Alexandra,T-shirt的价格是15便士。''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.prepare_image_inputs() SCREAMING_SNAKE_CASE_ : int = processor(text=lowercase_ , images=lowercase_) self.assertListEqual(list(inputs.keys()) , ['''input_ids''', '''token_type_ids''', '''attention_mask''', '''pixel_values''']) # test if it raises when no input is passed with pytest.raises(lowercase_): processor() def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.get_image_processor() SCREAMING_SNAKE_CASE_ : List[Any] = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : Optional[int] = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) SCREAMING_SNAKE_CASE_ : Any = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] SCREAMING_SNAKE_CASE_ : Optional[int] = processor.batch_decode(lowercase_) SCREAMING_SNAKE_CASE_ : Dict = tokenizer.batch_decode(lowercase_) self.assertListEqual(lowercase_ , lowercase_) def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = self.get_image_processor() SCREAMING_SNAKE_CASE_ : Dict = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : Dict = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = '''Alexandra,T-shirt的价格是15便士。''' SCREAMING_SNAKE_CASE_ : Dict = self.prepare_image_inputs() SCREAMING_SNAKE_CASE_ : Dict = processor(text=lowercase_ , images=lowercase_) self.assertListEqual(list(inputs.keys()) , processor.model_input_names)
318
0
"""simple docstring""" import argparse import dataclasses import json import logging import os import shutil from typing import List, Optional import datasets from accelerate import Accelerator from datasets import load_dataset from finetuning import finetune from tqdm.auto import tqdm import transformers from transformers import AutoConfig, set_seed from transformers.trainer_utils import IntervalStrategy UpperCAmelCase_ : List[str] = logging.getLogger(__name__) UpperCAmelCase_ : List[Any] = """pytorch_model.bin""" @dataclasses.dataclass class lowerCAmelCase__ : '''simple docstring''' __UpperCamelCase = dataclasses.field( metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models."} ) __UpperCamelCase = dataclasses.field( default=UpperCAmelCase__ , metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co."} , ) @dataclasses.dataclass class lowerCAmelCase__ : '''simple docstring''' __UpperCamelCase = dataclasses.field(metadata={"help": "A csv or a json file containing the training data."} ) __UpperCamelCase = dataclasses.field(metadata={"help": "A csv or a json file containing the data to predict on."} ) __UpperCamelCase = dataclasses.field( default=UpperCAmelCase__ , metadata={"help": "A csv or a json file containing the validation data."} ) __UpperCamelCase = dataclasses.field( default=UpperCAmelCase__ , metadata={"help": "The name of the task to train on."} , ) __UpperCamelCase = dataclasses.field( default=UpperCAmelCase__ , metadata={"help": "The list of labels for the task."} ) @dataclasses.dataclass class lowerCAmelCase__ : '''simple docstring''' __UpperCamelCase = dataclasses.field( metadata={"help": "The output directory where the model predictions and checkpoints will be written."} ) __UpperCamelCase = dataclasses.field( default="accuracy" , metadata={"help": "The evaluation metric used for the task."} ) __UpperCamelCase = dataclasses.field( default="no" , metadata={ "help": "The evaluation strategy to adopt during training. Possible values are: [\"no\", \"step\", \"epoch]" } , ) __UpperCamelCase = dataclasses.field( default=1_0 , metadata={"help": "Number of evaluation calls with no improvement after which training will be stopped."} , ) __UpperCamelCase = dataclasses.field( default=0.0 , metadata={ "help": "How much the specified evaluation metric must improve to satisfy early stopping conditions." } , ) __UpperCamelCase = dataclasses.field( default=UpperCAmelCase__ , metadata={"help": "Whether to filter the pseudo-labeled data based on the confidence score."} , ) __UpperCamelCase = dataclasses.field( default=UpperCAmelCase__ , metadata={"help": "Whether to filter the pseudo-labeled data based on the validation performance."} , ) __UpperCamelCase = dataclasses.field( default=UpperCAmelCase__ , metadata={"help": "Whether to fine-tune on labeled data after pseudo training."} , ) __UpperCamelCase = dataclasses.field( default=0.0 , metadata={"help": "Confidence threshold for pseudo-labeled data filtering."} , ) __UpperCamelCase = dataclasses.field( default=1_0_0 , metadata={"help": "Number of evaluation calls with no improvement after which training will be stopped."} , ) __UpperCamelCase = dataclasses.field( default=UpperCAmelCase__ , metadata={"help": "Random seed for initialization."} , ) def _A (__a , __a , __a , __a , __a , __a ) -> List[Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : List[str] = datasets.concatenate_datasets([infer_input, infer_output] , axis=1 ) if args.do_filter_by_confidence: SCREAMING_SNAKE_CASE_ : Optional[int] = dataset.filter(lambda __a : example["probability"] > args.confidence_threshold ) if args.do_filter_by_val_performance: assert eval_result >= 0.0 and eval_result <= 1.0 SCREAMING_SNAKE_CASE_ : Union[str, Any] = int(eval_result * len(__a ) ) print(__a ) SCREAMING_SNAKE_CASE_ : List[Any] = dataset.sort('''probability''' , reverse=__a ) SCREAMING_SNAKE_CASE_ : Any = dataset.select(range(__a ) ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = dataset.remove_columns(['''label''', '''probability'''] ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = dataset.rename_column('''prediction''' , '''label''' ) SCREAMING_SNAKE_CASE_ : int = dataset.map(lambda __a : {"label": idalabel[example["label"]]} ) SCREAMING_SNAKE_CASE_ : Optional[Any] = dataset.shuffle(seed=args.seed ) SCREAMING_SNAKE_CASE_ : Optional[Any] = os.path.join(__a , f'train_pseudo.{args.data_file_extension}' ) if args.data_file_extension == "csv": dataset.to_csv(__a , index=__a ) else: dataset.to_json(__a ) def _A (__a , __a , __a , __a , **__a ) -> Dict: """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[int] = Accelerator() # 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.info(accelerator.state ) # Setup logging, we only want one process per machine to log things on the # screen. accelerator.is_local_main_process is only True for one process per # machine. logger.setLevel(logging.INFO if accelerator.is_local_main_process else logging.ERROR ) if accelerator.is_local_main_process: datasets.utils.logging.set_verbosity_warning() transformers.utils.logging.set_verbosity_info() else: datasets.utils.logging.set_verbosity_error() transformers.utils.logging.set_verbosity_error() SCREAMING_SNAKE_CASE_ : Union[str, Any] = STModelArguments(model_name_or_path=__a ) SCREAMING_SNAKE_CASE_ : int = STDataArguments(train_file=__a , infer_file=__a ) SCREAMING_SNAKE_CASE_ : Tuple = STTrainingArguments(output_dir=__a ) SCREAMING_SNAKE_CASE_ : List[str] = argparse.Namespace() for arg_class in (model_args, data_args, training_args): for key, value in vars(__a ).items(): setattr(__a , __a , __a ) for key, value in kwargs.items(): if hasattr(__a , __a ): setattr(__a , __a , __a ) # Sanity checks SCREAMING_SNAKE_CASE_ : Optional[int] = {} SCREAMING_SNAKE_CASE_ : Dict = None # You need to provide the training data and the data to predict on assert args.train_file is not None assert args.infer_file is not None SCREAMING_SNAKE_CASE_ : Tuple = args.train_file SCREAMING_SNAKE_CASE_ : List[str] = args.infer_file if args.evaluation_strategy != IntervalStrategy.NO.value: assert args.eval_file is not None SCREAMING_SNAKE_CASE_ : int = args.eval_file for key in data_files: SCREAMING_SNAKE_CASE_ : Optional[Any] = data_files[key].split('''.''' )[-1] assert extension in ["csv", "json"], f'`{key}_file` should be a csv or a json file.' if args.data_file_extension is None: SCREAMING_SNAKE_CASE_ : List[Any] = extension else: assert extension == args.data_file_extension, f'`{key}_file` should be a {args.data_file_extension} file`.' assert ( args.eval_metric in datasets.list_metrics() ), f'{args.eval_metric} not in the list of supported metrics {datasets.list_metrics()}.' # If passed along, set the training seed now. if args.seed is not None: set_seed(args.seed ) logger.info('''Creating the initial data directory for self-training...''' ) SCREAMING_SNAKE_CASE_ : Any = f'{args.output_dir}/self-train_iter-{{}}'.format SCREAMING_SNAKE_CASE_ : int = data_dir_format(0 ) if accelerator.is_main_process: if args.output_dir is not None: os.makedirs(args.output_dir , exist_ok=__a ) os.makedirs(__a , exist_ok=__a ) accelerator.wait_for_everyone() SCREAMING_SNAKE_CASE_ : Tuple = None SCREAMING_SNAKE_CASE_ : Optional[int] = None SCREAMING_SNAKE_CASE_ : List[Any] = 0 SCREAMING_SNAKE_CASE_ : List[str] = False # Show the progress bar SCREAMING_SNAKE_CASE_ : List[Any] = tqdm(range(args.max_selftrain_iterations ) , disable=not accelerator.is_local_main_process ) # Self-train for iteration in range(0 , int(args.max_selftrain_iterations ) ): SCREAMING_SNAKE_CASE_ : Any = data_dir_format(__a ) assert os.path.exists(__a ) # Stage 1: initial fine-tuning for iteration = 0 or pseudo-training for # iteration > 0 SCREAMING_SNAKE_CASE_ : Union[str, Any] = os.path.join(__a , '''stage-1''' ) SCREAMING_SNAKE_CASE_ : Optional[int] = { '''accelerator''': accelerator, '''model_name_or_path''': args.model_name_or_path, '''cache_dir''': args.cache_dir, '''do_train''': True, '''train_file''': data_files['''train'''] if iteration == 0 else data_files['''train_pseudo'''], '''do_eval''': True if args.eval_file is not None else False, '''eval_file''': data_files['''eval'''], '''do_predict''': True, '''infer_file''': data_files['''infer'''], '''task_name''': args.task_name, '''label_list''': args.label_list, '''output_dir''': current_output_dir, '''eval_metric''': args.eval_metric, '''evaluation_strategy''': args.evaluation_strategy, '''early_stopping_patience''': args.early_stopping_patience, '''early_stopping_threshold''': args.early_stopping_threshold, '''seed''': args.seed, } # Add additional training arguments for key, value in kwargs.items(): if key not in arguments_dict and not hasattr(__a , __a ): arguments_dict.update({key: value} ) SCREAMING_SNAKE_CASE_ : Dict = os.path.join(__a , '''best-checkpoint''' , __a ) if os.path.exists(__a ): logger.info( '''Found existing model checkpoint at %s. Skipping self-training: iteration: %d, stage: 1.''' , __a , __a , ) else: logger.info('''***** Running self-training: iteration: %d, stage: 1 *****''' , __a ) finetune(**__a ) accelerator.wait_for_everyone() assert os.path.exists(__a ) logger.info('''Self-training job completed: iteration: %d, stage: 1.''' , __a ) if iteration > 0 and args.finetune_on_labeled_data: # Stage 2 (optional): fine-tuning on the original labeled data SCREAMING_SNAKE_CASE_ : int = os.path.join(__a , '''best-checkpoint''' ) SCREAMING_SNAKE_CASE_ : Tuple = os.path.join(__a , '''stage-2''' ) # Update arguments_dict SCREAMING_SNAKE_CASE_ : List[str] = model_path SCREAMING_SNAKE_CASE_ : int = data_files['''train'''] SCREAMING_SNAKE_CASE_ : str = current_output_dir SCREAMING_SNAKE_CASE_ : Tuple = os.path.join(__a , '''best-checkpoint''' , __a ) if os.path.exists(__a ): logger.info( '''Found existing model checkpoint at %s. Skipping self-training: iteration: %d, stage: 2.''' , __a , __a , ) else: logger.info('''***** Running self-training: iteration: %d, stage: 2 *****''' , __a ) finetune(**__a ) accelerator.wait_for_everyone() assert os.path.exists(__a ) logger.info('''Self-training job completed: iteration: %d, stage: 2.''' , __a ) SCREAMING_SNAKE_CASE_ : Dict = iteration SCREAMING_SNAKE_CASE_ : Dict = data_dir_format(iteration + 1 ) SCREAMING_SNAKE_CASE_ : Tuple = AutoConfig.from_pretrained(os.path.join(__a , '''best-checkpoint''' ) ) SCREAMING_SNAKE_CASE_ : int = config.idalabel SCREAMING_SNAKE_CASE_ : str = os.path.join(__a , '''eval_results_best-checkpoint.json''' ) SCREAMING_SNAKE_CASE_ : Optional[Any] = os.path.join(__a , '''test_results_best-checkpoint.json''' ) assert os.path.exists(__a ) with open(__a , '''r''' ) as f: SCREAMING_SNAKE_CASE_ : Dict = float(json.load(__a )[args.eval_metric] ) SCREAMING_SNAKE_CASE_ : Any = os.path.join(__a , '''infer_output_best-checkpoint.csv''' ) assert os.path.exists(__a ) # Loading the dataset from local csv or json files. SCREAMING_SNAKE_CASE_ : List[Any] = load_dataset(args.data_file_extension , data_files={'''data''': data_files['''infer''']} )['''data'''] SCREAMING_SNAKE_CASE_ : List[Any] = load_dataset('''csv''' , data_files={'''data''': infer_output_file} )['''data'''] if accelerator.is_main_process: os.makedirs(__a , exist_ok=__a ) shutil.copy(__a , os.path.join(__a , f'eval_results_iter-{iteration}.json' ) ) if os.path.exists(__a ): shutil.copy(__a , os.path.join(__a , f'test_results_iter-{iteration}.json' ) ) create_pseudo_labeled_data(__a , __a , __a , __a , __a , __a ) accelerator.wait_for_everyone() SCREAMING_SNAKE_CASE_ : Optional[Any] = os.path.join(__a , f'train_pseudo.{args.data_file_extension}' ) if args.evaluation_strategy != IntervalStrategy.NO.value: SCREAMING_SNAKE_CASE_ : Optional[int] = eval_result if best_iteration is None: SCREAMING_SNAKE_CASE_ : List[Any] = new_iteration SCREAMING_SNAKE_CASE_ : List[Any] = new_eval_result else: if new_eval_result - best_eval_result > args.early_stopping_threshold: SCREAMING_SNAKE_CASE_ : Optional[Any] = new_iteration SCREAMING_SNAKE_CASE_ : Union[str, Any] = new_eval_result SCREAMING_SNAKE_CASE_ : int = 0 else: if new_eval_result == best_eval_result: SCREAMING_SNAKE_CASE_ : List[str] = new_iteration SCREAMING_SNAKE_CASE_ : Optional[Any] = new_eval_result early_stopping_patience_counter += 1 if early_stopping_patience_counter >= args.early_stopping_patience: SCREAMING_SNAKE_CASE_ : List[Any] = True progress_bar.update(1 ) if should_training_stop: break if best_iteration is not None: # Save the best iteration logger.info('''Best iteration: %d''' , __a ) logger.info('''Best evaluation result: %s = %f''' , args.eval_metric , __a ) accelerator.wait_for_everyone() if accelerator.is_main_process: shutil.copy( os.path.join(__a , f'eval_results_iter-{iteration}.json' ) , os.path.join(__a , '''eval_results_best-iteration.json''' ) , ) else: # Assume that the last iteration is the best logger.info('''Best iteration: %d''' , args.max_selftrain_iterations - 1 ) logger.info('''Best evaluation result: %s = %f''' , args.eval_metric , __a ) accelerator.wait_for_everyone() if accelerator.is_main_process: shutil.copy( os.path.join(__a , f'eval_results_iter-{args.max_selftrain_iterations - 1}.json' ) , os.path.join(__a , '''eval_results_best-iteration.json''' ) , )
353
"""simple docstring""" from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCAmelCase_ : Dict = logging.get_logger(__name__) UpperCAmelCase_ : List[str] = { """RWKV/rwkv-4-169m-pile""": """https://huggingface.co/RWKV/rwkv-4-169m-pile/resolve/main/config.json""", """RWKV/rwkv-4-430m-pile""": """https://huggingface.co/RWKV/rwkv-4-430m-pile/resolve/main/config.json""", """RWKV/rwkv-4-1b5-pile""": """https://huggingface.co/RWKV/rwkv-4-1b5-pile/resolve/main/config.json""", """RWKV/rwkv-4-3b-pile""": """https://huggingface.co/RWKV/rwkv-4-3b-pile/resolve/main/config.json""", """RWKV/rwkv-4-7b-pile""": """https://huggingface.co/RWKV/rwkv-4-7b-pile/resolve/main/config.json""", """RWKV/rwkv-4-14b-pile""": """https://huggingface.co/RWKV/rwkv-4-14b-pile/resolve/main/config.json""", """RWKV/rwkv-raven-1b5""": """https://huggingface.co/RWKV/rwkv-raven-1b5/resolve/main/config.json""", """RWKV/rwkv-raven-3b""": """https://huggingface.co/RWKV/rwkv-raven-3b/resolve/main/config.json""", """RWKV/rwkv-raven-7b""": """https://huggingface.co/RWKV/rwkv-raven-7b/resolve/main/config.json""", """RWKV/rwkv-raven-14b""": """https://huggingface.co/RWKV/rwkv-raven-14b/resolve/main/config.json""", } class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = "rwkv" __UpperCamelCase = {"max_position_embeddings": "context_length"} def __init__( self : Union[str, Any] , lowercase_ : Any=50277 , lowercase_ : str=1024 , lowercase_ : List[str]=4096 , lowercase_ : Optional[Any]=32 , lowercase_ : Any=None , lowercase_ : Any=None , lowercase_ : List[Any]=1e-5 , lowercase_ : Union[str, Any]=0 , lowercase_ : Union[str, Any]=0 , lowercase_ : int=6 , lowercase_ : Tuple=False , lowercase_ : Any=True , **lowercase_ : Any , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = vocab_size SCREAMING_SNAKE_CASE_ : Any = context_length SCREAMING_SNAKE_CASE_ : int = hidden_size SCREAMING_SNAKE_CASE_ : int = num_hidden_layers SCREAMING_SNAKE_CASE_ : List[str] = attention_hidden_size if attention_hidden_size is not None else hidden_size SCREAMING_SNAKE_CASE_ : int = intermediate_size if intermediate_size is not None else 4 * hidden_size SCREAMING_SNAKE_CASE_ : int = layer_norm_epsilon SCREAMING_SNAKE_CASE_ : Optional[int] = rescale_every SCREAMING_SNAKE_CASE_ : Dict = use_cache SCREAMING_SNAKE_CASE_ : Dict = bos_token_id SCREAMING_SNAKE_CASE_ : Any = eos_token_id super().__init__( tie_word_embeddings=lowercase_ , bos_token_id=lowercase_ , eos_token_id=lowercase_ , **lowercase_)
318
0
"""simple docstring""" import importlib import json import os from collections import OrderedDict from typing import Dict, Optional, Union # Build the list of all feature extractors from ...configuration_utils import PretrainedConfig from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code from ...feature_extraction_utils import FeatureExtractionMixin from ...utils import CONFIG_NAME, FEATURE_EXTRACTOR_NAME, get_file_from_repo, logging from .auto_factory import _LazyAutoMapping from .configuration_auto import ( CONFIG_MAPPING_NAMES, AutoConfig, model_type_to_module_name, replace_list_option_in_docstrings, ) UpperCAmelCase_ = logging.get_logger(__name__) UpperCAmelCase_ = OrderedDict( [ ("""audio-spectrogram-transformer""", """ASTFeatureExtractor"""), ("""beit""", """BeitFeatureExtractor"""), ("""chinese_clip""", """ChineseCLIPFeatureExtractor"""), ("""clap""", """ClapFeatureExtractor"""), ("""clip""", """CLIPFeatureExtractor"""), ("""clipseg""", """ViTFeatureExtractor"""), ("""conditional_detr""", """ConditionalDetrFeatureExtractor"""), ("""convnext""", """ConvNextFeatureExtractor"""), ("""cvt""", """ConvNextFeatureExtractor"""), ("""data2vec-audio""", """Wav2Vec2FeatureExtractor"""), ("""data2vec-vision""", """BeitFeatureExtractor"""), ("""deformable_detr""", """DeformableDetrFeatureExtractor"""), ("""deit""", """DeiTFeatureExtractor"""), ("""detr""", """DetrFeatureExtractor"""), ("""dinat""", """ViTFeatureExtractor"""), ("""donut-swin""", """DonutFeatureExtractor"""), ("""dpt""", """DPTFeatureExtractor"""), ("""encodec""", """EncodecFeatureExtractor"""), ("""flava""", """FlavaFeatureExtractor"""), ("""glpn""", """GLPNFeatureExtractor"""), ("""groupvit""", """CLIPFeatureExtractor"""), ("""hubert""", """Wav2Vec2FeatureExtractor"""), ("""imagegpt""", """ImageGPTFeatureExtractor"""), ("""layoutlmv2""", """LayoutLMv2FeatureExtractor"""), ("""layoutlmv3""", """LayoutLMv3FeatureExtractor"""), ("""levit""", """LevitFeatureExtractor"""), ("""maskformer""", """MaskFormerFeatureExtractor"""), ("""mctct""", """MCTCTFeatureExtractor"""), ("""mobilenet_v1""", """MobileNetV1FeatureExtractor"""), ("""mobilenet_v2""", """MobileNetV2FeatureExtractor"""), ("""mobilevit""", """MobileViTFeatureExtractor"""), ("""nat""", """ViTFeatureExtractor"""), ("""owlvit""", """OwlViTFeatureExtractor"""), ("""perceiver""", """PerceiverFeatureExtractor"""), ("""poolformer""", """PoolFormerFeatureExtractor"""), ("""regnet""", """ConvNextFeatureExtractor"""), ("""resnet""", """ConvNextFeatureExtractor"""), ("""segformer""", """SegformerFeatureExtractor"""), ("""sew""", """Wav2Vec2FeatureExtractor"""), ("""sew-d""", """Wav2Vec2FeatureExtractor"""), ("""speech_to_text""", """Speech2TextFeatureExtractor"""), ("""speecht5""", """SpeechT5FeatureExtractor"""), ("""swiftformer""", """ViTFeatureExtractor"""), ("""swin""", """ViTFeatureExtractor"""), ("""swinv2""", """ViTFeatureExtractor"""), ("""table-transformer""", """DetrFeatureExtractor"""), ("""timesformer""", """VideoMAEFeatureExtractor"""), ("""tvlt""", """TvltFeatureExtractor"""), ("""unispeech""", """Wav2Vec2FeatureExtractor"""), ("""unispeech-sat""", """Wav2Vec2FeatureExtractor"""), ("""van""", """ConvNextFeatureExtractor"""), ("""videomae""", """VideoMAEFeatureExtractor"""), ("""vilt""", """ViltFeatureExtractor"""), ("""vit""", """ViTFeatureExtractor"""), ("""vit_mae""", """ViTFeatureExtractor"""), ("""vit_msn""", """ViTFeatureExtractor"""), ("""wav2vec2""", """Wav2Vec2FeatureExtractor"""), ("""wav2vec2-conformer""", """Wav2Vec2FeatureExtractor"""), ("""wavlm""", """Wav2Vec2FeatureExtractor"""), ("""whisper""", """WhisperFeatureExtractor"""), ("""xclip""", """CLIPFeatureExtractor"""), ("""yolos""", """YolosFeatureExtractor"""), ] ) UpperCAmelCase_ = _LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES) def _A (__a ) -> List[Any]: """simple docstring""" for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items(): if class_name in extractors: SCREAMING_SNAKE_CASE_ : Optional[int] = model_type_to_module_name(__a ) SCREAMING_SNAKE_CASE_ : List[str] = importlib.import_module(f'.{module_name}' , '''transformers.models''' ) try: return getattr(__a , __a ) except AttributeError: continue for _, extractor in FEATURE_EXTRACTOR_MAPPING._extra_content.items(): if getattr(__a , '''__name__''' , __a ) == class_name: return extractor # We did not fine the class, but maybe it's because a dep is missing. In that case, the class will be in the main # init and we return the proper dummy to get an appropriate error message. SCREAMING_SNAKE_CASE_ : Optional[Any] = importlib.import_module('''transformers''' ) if hasattr(__a , __a ): return getattr(__a , __a ) return None def _A (__a , __a = None , __a = False , __a = False , __a = None , __a = None , __a = None , __a = False , **__a , ) -> Any: """simple docstring""" SCREAMING_SNAKE_CASE_ : Tuple = get_file_from_repo( __a , __a , cache_dir=__a , force_download=__a , resume_download=__a , proxies=__a , use_auth_token=__a , revision=__a , local_files_only=__a , ) if resolved_config_file is None: logger.info( '''Could not locate the feature extractor configuration file, will try to use the model config instead.''' ) return {} with open(__a , encoding='''utf-8''' ) as reader: return json.load(__a ) class lowerCAmelCase__ : '''simple docstring''' def __init__( self : Tuple): '''simple docstring''' raise EnvironmentError( '''AutoFeatureExtractor is designed to be instantiated ''' '''using the `AutoFeatureExtractor.from_pretrained(pretrained_model_name_or_path)` method.''') @classmethod @replace_list_option_in_docstrings(lowercase_) def _SCREAMING_SNAKE_CASE ( cls : List[str] , lowercase_ : int , **lowercase_ : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = kwargs.pop('''config''' , lowercase_) SCREAMING_SNAKE_CASE_ : Dict = kwargs.pop('''trust_remote_code''' , lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = True SCREAMING_SNAKE_CASE_ : List[str] = FeatureExtractionMixin.get_feature_extractor_dict(lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : str = config_dict.get('''feature_extractor_type''' , lowercase_) SCREAMING_SNAKE_CASE_ : Optional[Any] = None if "AutoFeatureExtractor" in config_dict.get('''auto_map''' , {}): SCREAMING_SNAKE_CASE_ : str = config_dict['''auto_map''']['''AutoFeatureExtractor'''] # If we don't find the feature extractor class in the feature extractor config, let's try the model config. if feature_extractor_class is None and feature_extractor_auto_map is None: if not isinstance(lowercase_ , lowercase_): SCREAMING_SNAKE_CASE_ : Dict = AutoConfig.from_pretrained(lowercase_ , **lowercase_) # It could be in `config.feature_extractor_type`` SCREAMING_SNAKE_CASE_ : Dict = getattr(lowercase_ , '''feature_extractor_type''' , lowercase_) if hasattr(lowercase_ , '''auto_map''') and "AutoFeatureExtractor" in config.auto_map: SCREAMING_SNAKE_CASE_ : Optional[int] = config.auto_map['''AutoFeatureExtractor'''] if feature_extractor_class is not None: SCREAMING_SNAKE_CASE_ : Any = feature_extractor_class_from_name(lowercase_) SCREAMING_SNAKE_CASE_ : int = feature_extractor_auto_map is not None SCREAMING_SNAKE_CASE_ : Any = feature_extractor_class is not None or type(lowercase_) in FEATURE_EXTRACTOR_MAPPING SCREAMING_SNAKE_CASE_ : Optional[int] = resolve_trust_remote_code( lowercase_ , lowercase_ , lowercase_ , lowercase_) if has_remote_code and trust_remote_code: SCREAMING_SNAKE_CASE_ : Optional[int] = get_class_from_dynamic_module( lowercase_ , lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = kwargs.pop('''code_revision''' , lowercase_) if os.path.isdir(lowercase_): feature_extractor_class.register_for_auto_class() return feature_extractor_class.from_dict(lowercase_ , **lowercase_) elif feature_extractor_class is not None: return feature_extractor_class.from_dict(lowercase_ , **lowercase_) # Last try: we use the FEATURE_EXTRACTOR_MAPPING. elif type(lowercase_) in FEATURE_EXTRACTOR_MAPPING: SCREAMING_SNAKE_CASE_ : int = FEATURE_EXTRACTOR_MAPPING[type(lowercase_)] return feature_extractor_class.from_dict(lowercase_ , **lowercase_) raise ValueError( F'Unrecognized feature extractor in {pretrained_model_name_or_path}. Should have a ' F'`feature_extractor_type` key in its {FEATURE_EXTRACTOR_NAME} of {CONFIG_NAME}, or one of the following ' F'`model_type` keys in its {CONFIG_NAME}: {", ".join(c for c in FEATURE_EXTRACTOR_MAPPING_NAMES.keys())}') @staticmethod def _SCREAMING_SNAKE_CASE ( lowercase_ : Optional[int] , lowercase_ : Any): '''simple docstring''' FEATURE_EXTRACTOR_MAPPING.register(lowercase_ , lowercase_)
354
"""simple docstring""" UpperCAmelCase_ : Optional[int] = 8.3_1_4_4_5_9_8 def _A (__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 UpperCAmelCase_ : str = 300 UpperCAmelCase_ : str = 28 UpperCAmelCase_ : Any = rms_speed_of_molecule(temperature, molar_mass) print(f'''Vrms of Nitrogen gas at 300 K is {vrms} m/s''')
318
0
"""simple docstring""" import gc import importlib.metadata import tempfile import unittest from packaging import version from transformers import ( AutoModel, AutoModelForCausalLM, AutoModelForSeqaSeqLM, AutoModelForSequenceClassification, AutoTokenizer, BitsAndBytesConfig, pipeline, ) from transformers.testing_utils import ( is_torch_available, require_accelerate, require_bitsandbytes, require_torch, require_torch_gpu, require_torch_multi_gpu, slow, ) def _A (__a ) -> str: """simple docstring""" if model.config.model_type == "gpt2": return model.transformer.h[0].mlp.c_fc return model.transformer.h[0].mlp.dense_ah_to_h if is_torch_available(): import torch import torch.nn as nn class lowerCAmelCase__ ( nn.Module ): '''simple docstring''' def __init__( self : Optional[int] , lowercase_ : nn.Module , lowercase_ : int): '''simple docstring''' super().__init__() SCREAMING_SNAKE_CASE_ : Dict = module SCREAMING_SNAKE_CASE_ : Dict = nn.Sequential( nn.Linear(module.in_features , lowercase_ , bias=lowercase_) , nn.Linear(lowercase_ , module.out_features , bias=lowercase_) , ) SCREAMING_SNAKE_CASE_ : str = (2.0 / (5 * min(module.in_features , module.out_features))) ** 0.5 nn.init.normal_(self.adapter[0].weight , std=lowercase_) nn.init.zeros_(self.adapter[1].weight) self.adapter.to(module.weight.device) def _SCREAMING_SNAKE_CASE ( self : str , lowercase_ : Any , *lowercase_ : Dict , **lowercase_ : Any): '''simple docstring''' return self.module(lowercase_ , *lowercase_ , **lowercase_) + self.adapter(lowercase_) @require_bitsandbytes @require_accelerate @require_torch @require_torch_gpu @slow class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' __UpperCamelCase = "bigscience/bloom-1b7" # Constant values __UpperCamelCase = 2.1_0_9_6_5_9_5_5_2_6_9_2_5_7_4 __UpperCamelCase = "Hello my name is" __UpperCamelCase = set() EXPECTED_OUTPUTS.add("Hello my name is John and I am a professional photographer. I" ) EXPECTED_OUTPUTS.add("Hello my name is John.\nI am a friend of your father.\n" ) EXPECTED_OUTPUTS.add("Hello my name is John Doe, I am a student at the University" ) __UpperCamelCase = 1_0 def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = AutoTokenizer.from_pretrained(self.model_name) class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : Tuple): '''simple docstring''' super().setUp() # Models and tokenizer SCREAMING_SNAKE_CASE_ : Dict = AutoModelForCausalLM.from_pretrained( self.model_name , torch_dtype=torch.floataa , device_map='''auto''') SCREAMING_SNAKE_CASE_ : str = AutoModelForCausalLM.from_pretrained(self.model_name , load_in_abit=lowercase_ , device_map='''auto''') def _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' del self.model_fpaa del self.model_abit gc.collect() torch.cuda.empty_cache() def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = self.model_abit.config self.assertTrue(hasattr(lowercase_ , '''quantization_config''')) SCREAMING_SNAKE_CASE_ : int = config.to_dict() SCREAMING_SNAKE_CASE_ : Optional[Any] = config.to_diff_dict() SCREAMING_SNAKE_CASE_ : Dict = config.to_json_string() def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' from bitsandbytes.nn import Paramsabit SCREAMING_SNAKE_CASE_ : str = self.model_fpaa.get_memory_footprint() SCREAMING_SNAKE_CASE_ : Optional[int] = self.model_abit.get_memory_footprint() self.assertAlmostEqual(mem_fpaa / mem_abit , self.EXPECTED_RELATIVE_DIFFERENCE) SCREAMING_SNAKE_CASE_ : List[Any] = get_some_linear_layer(self.model_abit) self.assertTrue(linear.weight.__class__ == Paramsabit) def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' from transformers import TaPreTrainedModel self.model_fpaa.get_memory_footprint() self.model_abit.get_memory_footprint() for name, module in self.model_abit.named_modules(): if isinstance(lowercase_ , torch.nn.Linear): if name not in ["lm_head"] + TaPreTrainedModel._keep_in_fpaa_modules: # 4-bit parameters are packed in uint8 variables self.assertTrue(module.weight.dtype == torch.uinta) def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = self.tokenizer(self.input_text , return_tensors='''pt''') SCREAMING_SNAKE_CASE_ : int = self.model_abit.generate(input_ids=encoded_input['''input_ids'''].to(0) , max_new_tokens=10) self.assertIn(self.tokenizer.decode(output_sequences[0] , skip_special_tokens=lowercase_) , self.EXPECTED_OUTPUTS) def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = BitsAndBytesConfig() SCREAMING_SNAKE_CASE_ : Optional[int] = True SCREAMING_SNAKE_CASE_ : Union[str, Any] = AutoModelForCausalLM.from_pretrained( self.model_name , quantization_config=lowercase_ , device_map='''auto''') SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.tokenizer(self.input_text , return_tensors='''pt''') SCREAMING_SNAKE_CASE_ : Optional[int] = model_abit_from_config.generate( input_ids=encoded_input['''input_ids'''].to(0) , max_new_tokens=10) self.assertIn(self.tokenizer.decode(output_sequences[0] , skip_special_tokens=lowercase_) , self.EXPECTED_OUTPUTS) def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' with self.assertRaises(lowercase_), tempfile.TemporaryDirectory() as tmpdirname: self.model_abit.save_pretrained(lowercase_) def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = BitsAndBytesConfig() with self.assertRaises(lowercase_): SCREAMING_SNAKE_CASE_ : Any = AutoModelForCausalLM.from_pretrained( self.model_name , quantization_config=lowercase_ , load_in_abit=lowercase_ , device_map='''auto''' , bnb_abit_quant_type='''nf4''' , ) def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' with self.assertRaises(lowercase_): # Tries with `str` self.model_abit.to('''cpu''') with self.assertRaises(lowercase_): # Tries with a `dtype`` self.model_abit.to(torch.floataa) with self.assertRaises(lowercase_): # Tries with a `device` self.model_abit.to(torch.device('''cuda:0''')) with self.assertRaises(lowercase_): # Tries with a `device` self.model_abit.float() with self.assertRaises(lowercase_): # Tries with a `device` self.model_abit.half() # Test if we did not break anything SCREAMING_SNAKE_CASE_ : Any = self.tokenizer(self.input_text , return_tensors='''pt''') SCREAMING_SNAKE_CASE_ : Dict = self.model_fpaa.to(torch.floataa) SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.model_fpaa.generate(input_ids=encoded_input['''input_ids'''].to(0) , max_new_tokens=10) # Check this does not throw an error SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.model_fpaa.to('''cpu''') # Check this does not throw an error SCREAMING_SNAKE_CASE_ : Tuple = self.model_fpaa.half() # Check this does not throw an error SCREAMING_SNAKE_CASE_ : int = self.model_fpaa.float() def _SCREAMING_SNAKE_CASE ( self : Any): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = AutoModelForSeqaSeqLM.from_pretrained('''t5-small''' , load_in_abit=lowercase_ , device_map='''auto''') self.assertTrue(model.decoder.block[0].layer[2].DenseReluDense.wo.weight.dtype == torch.floataa) @require_bitsandbytes @require_accelerate @require_torch @require_torch_gpu @slow class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' @classmethod def _SCREAMING_SNAKE_CASE ( cls : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = '''t5-small''' SCREAMING_SNAKE_CASE_ : str = '''google/flan-t5-small''' # flan-t5 uses dense-act instead of dense-relu-dense SCREAMING_SNAKE_CASE_ : List[str] = AutoTokenizer.from_pretrained(cls.model_name) SCREAMING_SNAKE_CASE_ : str = '''Translate in German: Hello, my dog is cute''' def _SCREAMING_SNAKE_CASE ( self : Any): '''simple docstring''' gc.collect() torch.cuda.empty_cache() def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' from transformers import TaForConditionalGeneration SCREAMING_SNAKE_CASE_ : List[str] = TaForConditionalGeneration._keep_in_fpaa_modules SCREAMING_SNAKE_CASE_ : List[str] = None # test with `t5-small` SCREAMING_SNAKE_CASE_ : Union[str, Any] = TaForConditionalGeneration.from_pretrained(self.model_name , load_in_abit=lowercase_ , device_map='''auto''') SCREAMING_SNAKE_CASE_ : Optional[int] = self.tokenizer(self.input_text , return_tensors='''pt''').to(0) SCREAMING_SNAKE_CASE_ : Union[str, Any] = model.generate(**lowercase_) # test with `flan-t5-small` SCREAMING_SNAKE_CASE_ : Dict = TaForConditionalGeneration.from_pretrained( self.dense_act_model_name , load_in_abit=lowercase_ , device_map='''auto''') SCREAMING_SNAKE_CASE_ : str = self.tokenizer(self.input_text , return_tensors='''pt''').to(0) SCREAMING_SNAKE_CASE_ : Dict = model.generate(**lowercase_) SCREAMING_SNAKE_CASE_ : int = modules def _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' import bitsandbytes as bnb from transformers import TaForConditionalGeneration # test with `t5-small` SCREAMING_SNAKE_CASE_ : List[Any] = TaForConditionalGeneration.from_pretrained(self.model_name , load_in_abit=lowercase_ , device_map='''auto''') # there was a bug with decoders - this test checks that it is fixed self.assertTrue(isinstance(model.decoder.block[0].layer[0].SelfAttention.q , bnb.nn.Linearabit)) SCREAMING_SNAKE_CASE_ : Optional[int] = self.tokenizer(self.input_text , return_tensors='''pt''').to(0) SCREAMING_SNAKE_CASE_ : int = model.generate(**lowercase_) # test with `flan-t5-small` SCREAMING_SNAKE_CASE_ : Tuple = TaForConditionalGeneration.from_pretrained( self.dense_act_model_name , load_in_abit=lowercase_ , device_map='''auto''') SCREAMING_SNAKE_CASE_ : str = self.tokenizer(self.input_text , return_tensors='''pt''').to(0) SCREAMING_SNAKE_CASE_ : List[Any] = model.generate(**lowercase_) class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' super().setUp() # model_name SCREAMING_SNAKE_CASE_ : Optional[int] = '''bigscience/bloom-560m''' SCREAMING_SNAKE_CASE_ : Any = '''t5-small''' # Different types of model SCREAMING_SNAKE_CASE_ : str = AutoModel.from_pretrained(self.model_name , load_in_abit=lowercase_ , device_map='''auto''') # Sequence classification model SCREAMING_SNAKE_CASE_ : Tuple = AutoModelForSequenceClassification.from_pretrained( self.model_name , load_in_abit=lowercase_ , device_map='''auto''') # CausalLM model SCREAMING_SNAKE_CASE_ : List[Any] = AutoModelForCausalLM.from_pretrained(self.model_name , load_in_abit=lowercase_ , device_map='''auto''') # Seq2seq model SCREAMING_SNAKE_CASE_ : List[Any] = AutoModelForSeqaSeqLM.from_pretrained( self.seq_to_seq_name , load_in_abit=lowercase_ , device_map='''auto''') def _SCREAMING_SNAKE_CASE ( self : Any): '''simple docstring''' del self.base_model del self.sequence_model del self.model_abit del self.seq_to_seq_model gc.collect() torch.cuda.empty_cache() def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' from bitsandbytes.nn import Paramsabit self.assertTrue(self.base_model.h[-1].mlp.dense_ah_to_h.weight.__class__ == Paramsabit) # Other heads should be nn.Parameter self.assertTrue(self.model_abit.lm_head.weight.__class__ == torch.nn.Parameter) self.assertTrue(self.sequence_model.score.weight.__class__ == torch.nn.Parameter) self.assertTrue(self.seq_to_seq_model.lm_head.weight.__class__ == torch.nn.Parameter) class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : Any): '''simple docstring''' super().setUp() def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' del self.pipe gc.collect() torch.cuda.empty_cache() def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = pipeline( '''text-generation''' , model=self.model_name , model_kwargs={'''device_map''': '''auto''', '''load_in_4bit''': True, '''torch_dtype''': torch.floataa} , max_new_tokens=self.MAX_NEW_TOKENS , ) # Real second forward pass SCREAMING_SNAKE_CASE_ : int = self.pipe(self.input_text) self.assertIn(pipeline_output[0]['''generated_text'''] , self.EXPECTED_OUTPUTS) @require_torch_multi_gpu class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' super().setUp() def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = AutoModelForCausalLM.from_pretrained( self.model_name , load_in_abit=lowercase_ , device_map='''balanced''') # Check correct device map self.assertEqual(set(model_parallel.hf_device_map.values()) , {0, 1}) # Check that inference pass works on the model SCREAMING_SNAKE_CASE_ : List[str] = self.tokenizer(self.input_text , return_tensors='''pt''') # Second real batch SCREAMING_SNAKE_CASE_ : Optional[Any] = model_parallel.generate(input_ids=encoded_input['''input_ids'''].to(0) , max_new_tokens=10) self.assertIn(self.tokenizer.decode(output_parallel[0] , skip_special_tokens=lowercase_) , self.EXPECTED_OUTPUTS) class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[str] = '''facebook/opt-350m''' super().setUp() def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' if version.parse(importlib.metadata.version('''bitsandbytes''')) < version.parse('''0.37.0'''): return # Step 1: freeze all parameters SCREAMING_SNAKE_CASE_ : Union[str, Any] = AutoModelForCausalLM.from_pretrained(self.model_name , load_in_abit=lowercase_) self.assertEqual(set(model.hf_device_map.values()) , {torch.cuda.current_device()}) for param in model.parameters(): SCREAMING_SNAKE_CASE_ : Optional[Any] = False # freeze the model - train adapters later if param.ndim == 1: # cast the small parameters (e.g. layernorm) to fp32 for stability SCREAMING_SNAKE_CASE_ : Dict = param.data.to(torch.floataa) # Step 2: add adapters for _, module in model.named_modules(): if "OPTAttention" in repr(type(lowercase_)): SCREAMING_SNAKE_CASE_ : int = LoRALayer(module.q_proj , rank=16) SCREAMING_SNAKE_CASE_ : str = LoRALayer(module.k_proj , rank=16) SCREAMING_SNAKE_CASE_ : str = LoRALayer(module.v_proj , rank=16) # Step 3: dummy batch SCREAMING_SNAKE_CASE_ : Optional[Any] = self.tokenizer('''Test batch ''' , return_tensors='''pt''').to(0) # Step 4: Check if the gradient is not None with torch.cuda.amp.autocast(): SCREAMING_SNAKE_CASE_ : List[Any] = model.forward(**lowercase_) out.logits.norm().backward() for module in model.modules(): if isinstance(lowercase_ , lowercase_): self.assertTrue(module.adapter[1].weight.grad is not None) self.assertTrue(module.adapter[1].weight.grad.norm().item() > 0) elif isinstance(lowercase_ , nn.Embedding): self.assertTrue(module.weight.grad is None) class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = "gpt2-xl" __UpperCamelCase = 3.3_1_9_1_8_5_4_8_5_4_1_5_2_1_8_7
355
"""simple docstring""" import json import multiprocessing import os import re from collections import defaultdict import torch from accelerate import Accelerator from accelerate.utils import set_seed from arguments import HumanEvalArguments from datasets import load_dataset, load_metric from torch.utils.data import IterableDataset from torch.utils.data.dataloader import DataLoader from tqdm import tqdm import transformers from transformers import AutoModelForCausalLM, AutoTokenizer, HfArgumentParser, StoppingCriteria, StoppingCriteriaList UpperCAmelCase_ : Union[str, Any] = ["""\nclass""", """\ndef""", """\n#""", """\n@""", """\nprint""", """\nif"""] class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def __init__( self : List[Any] , lowercase_ : Tuple , lowercase_ : Optional[int] , lowercase_ : int=None , lowercase_ : Dict=1): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = tokenizer SCREAMING_SNAKE_CASE_ : Optional[int] = dataset SCREAMING_SNAKE_CASE_ : Optional[Any] = len(lowercase_) if n_tasks is None else n_tasks SCREAMING_SNAKE_CASE_ : Optional[int] = n_copies def __iter__( self : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = [] for task in range(self.n_tasks): # without strip, the model generate commented codes ... prompts.append(self.tokenizer.eos_token + self.dataset[task]['''prompt'''].strip()) SCREAMING_SNAKE_CASE_ : Optional[Any] = self.tokenizer(lowercase_ , padding=lowercase_ , return_tensors='''pt''') for task in range(self.n_tasks): for _ in range(self.n_copies): yield { "ids": outputs.input_ids[task], "task_id": task, "input_len": outputs.attention_mask[task].sum(), } class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def __init__( self : int , lowercase_ : Dict , lowercase_ : Optional[Any] , lowercase_ : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = start_length SCREAMING_SNAKE_CASE_ : List[Any] = eof_strings SCREAMING_SNAKE_CASE_ : List[Any] = tokenizer def __call__( self : Optional[int] , lowercase_ : Any , lowercase_ : int , **lowercase_ : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = self.tokenizer.batch_decode(input_ids[:, self.start_length :]) SCREAMING_SNAKE_CASE_ : Tuple = [] for decoded_generation in decoded_generations: done.append(any(stop_string in decoded_generation for stop_string in self.eof_strings)) return all(lowercase_) def _A (__a ) -> Union[str, Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Dict = re.split('''(%s)''' % '''|'''.join(__a ) , __a ) # last string should be "" return "".join(string_list[:-2] ) def _A (__a , __a , __a , __a , __a , __a=20 , **__a ) -> List[str]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Tuple = defaultdict(__a ) # dict of list of generated tokens for step, batch in tqdm(enumerate(__a ) ): with torch.no_grad(): SCREAMING_SNAKE_CASE_ : Optional[int] = batch['''ids'''].shape[-1] SCREAMING_SNAKE_CASE_ : Tuple = accelerator.unwrap_model(__a ).generate( input_ids=batch['''ids'''][:, : batch['''input_len''']] , num_return_sequences=__a , **__a ) # each task is generated batch_size times SCREAMING_SNAKE_CASE_ : List[Any] = batch['''task_id'''].repeat(__a ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = accelerator.pad_across_processes( __a , dim=1 , pad_index=tokenizer.pad_token_id ) SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Union[str, Any] = accelerator.gather((generated_tokens, generated_tasks) ) SCREAMING_SNAKE_CASE_ : int = generated_tokens.cpu().numpy() SCREAMING_SNAKE_CASE_ : Optional[Any] = generated_tasks.cpu().numpy() for task, generated_tokens in zip(__a , __a ): gen_token_dict[task].append(__a ) SCREAMING_SNAKE_CASE_ : int = [[] for _ in range(__a )] for task, generated_tokens in gen_token_dict.items(): for s in generated_tokens: SCREAMING_SNAKE_CASE_ : Optional[int] = tokenizer.decode(__a , skip_special_tokens=__a , clean_up_tokenization_spaces=__a ) code_gens[task].append(remove_last_block(__a ) ) return code_gens def _A () -> Optional[int]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Union[str, Any] = HfArgumentParser(__a ) SCREAMING_SNAKE_CASE_ : List[Any] = parser.parse_args() transformers.logging.set_verbosity_error() # enables code execution in code_eval metric SCREAMING_SNAKE_CASE_ : Any = args.HF_ALLOW_CODE_EVAL # make sure tokenizer plays nice with multiprocessing SCREAMING_SNAKE_CASE_ : str = '''false''' if args.num_workers is None: SCREAMING_SNAKE_CASE_ : Optional[Any] = multiprocessing.cpu_count() # Use dataset load to feed to accelerate SCREAMING_SNAKE_CASE_ : Tuple = Accelerator() set_seed(args.seed , device_specific=__a ) # Load model and tokenizer SCREAMING_SNAKE_CASE_ : Dict = AutoTokenizer.from_pretrained(args.model_ckpt ) SCREAMING_SNAKE_CASE_ : Dict = tokenizer.eos_token SCREAMING_SNAKE_CASE_ : Optional[int] = AutoModelForCausalLM.from_pretrained(args.model_ckpt ) # Generation settings SCREAMING_SNAKE_CASE_ : List[str] = { '''do_sample''': args.do_sample, '''temperature''': args.temperature, '''max_new_tokens''': args.max_new_tokens, '''top_p''': args.top_p, '''top_k''': args.top_k, '''stopping_criteria''': StoppingCriteriaList([EndOfFunctionCriteria(0 , __a , __a )] ), } # Load evaluation dataset and metric SCREAMING_SNAKE_CASE_ : Optional[int] = load_dataset('''openai_humaneval''' ) SCREAMING_SNAKE_CASE_ : str = load_metric('''code_eval''' ) SCREAMING_SNAKE_CASE_ : int = args.num_tasks if args.num_tasks is not None else len(human_eval['''test'''] ) SCREAMING_SNAKE_CASE_ : List[str] = args.n_samples // args.batch_size SCREAMING_SNAKE_CASE_ : Union[str, Any] = TokenizedDataset(__a , human_eval['''test'''] , n_copies=__a , n_tasks=__a ) # do not confuse args.batch_size, which is actually the num_return_sequences SCREAMING_SNAKE_CASE_ : Optional[int] = DataLoader(__a , batch_size=1 ) # Run a quick test to see if code evaluation is enabled try: SCREAMING_SNAKE_CASE_ : Any = code_eval_metric.compute(references=[''''''] , predictions=[['''''']] ) except ValueError as exception: print( '''Code evaluation not enabled. Read the warning below carefully and then use `--HF_ALLOW_CODE_EVAL="1"`''' ''' flag to enable code evaluation.''' ) raise exception SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : int = accelerator.prepare(__a , __a ) SCREAMING_SNAKE_CASE_ : List[Any] = complete_code( __a , __a , __a , __a , n_tasks=__a , batch_size=args.batch_size , **__a , ) if accelerator.is_main_process: SCREAMING_SNAKE_CASE_ : int = [] for task in tqdm(range(__a ) ): SCREAMING_SNAKE_CASE_ : Tuple = human_eval['''test'''][task]['''test'''] SCREAMING_SNAKE_CASE_ : Tuple = f'check({human_eval["test"][task]["entry_point"]})' references.append('''\n''' + test_func + '''\n''' + entry_point ) # Evaluate completions with "code_eval" metric SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Dict = code_eval_metric.compute( references=__a , predictions=__a , num_workers=args.num_workers ) print(f'Results: {pass_at_k}' ) # Save results to json file with open(args.output_file , '''w''' ) as fp: json.dump(__a , __a ) # For some reason the folliwng seems to be necessary sometimes for code_eval to work nice with multiprocessing # https://stackoverflow.com/questions/60804599/python-multiprocessing-keeps-spawning-the-whole-script if __name__ == "__main__": main()
318
0
"""simple docstring""" import jax.numpy as jnp from ...utils import logging from ..ta.modeling_flax_ta import FlaxTaEncoderModel, FlaxTaForConditionalGeneration, FlaxTaModel from .configuration_mta import MTaConfig UpperCAmelCase_ : Dict = logging.get_logger(__name__) UpperCAmelCase_ : List[Any] = """T5Config""" def _A (__a , __a , __a ) -> jnp.ndarray: """simple docstring""" SCREAMING_SNAKE_CASE_ : str = jnp.zeros_like(__a ) SCREAMING_SNAKE_CASE_ : Tuple = shifted_input_ids.at[:, 1:].set(input_ids[:, :-1] ) SCREAMING_SNAKE_CASE_ : Optional[Any] = shifted_input_ids.at[:, 0].set(__a ) SCREAMING_SNAKE_CASE_ : List[Any] = jnp.where(shifted_input_ids == -1_00 , __a , __a ) return shifted_input_ids class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = "mt5" __UpperCamelCase = MTaConfig class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = "mt5" __UpperCamelCase = MTaConfig class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = "mt5" __UpperCamelCase = MTaConfig
356
"""simple docstring""" from ...processing_utils import ProcessorMixin class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = ["image_processor", "feature_extractor"] __UpperCamelCase = "TvltImageProcessor" __UpperCamelCase = "TvltFeatureExtractor" def __init__( self : int , lowercase_ : Optional[Any] , lowercase_ : Optional[Any]): '''simple docstring''' super().__init__(image_processor=lowercase_ , feature_extractor=lowercase_) SCREAMING_SNAKE_CASE_ : Union[str, Any] = image_processor SCREAMING_SNAKE_CASE_ : Optional[Any] = feature_extractor def __call__( self : Any , lowercase_ : str=None , lowercase_ : Optional[Any]=None , lowercase_ : Optional[Any]=None , lowercase_ : str=None , lowercase_ : int=False , lowercase_ : Union[str, Any]=False , *lowercase_ : List[Any] , **lowercase_ : List[str] , ): '''simple docstring''' if images is None and audio is None: raise ValueError('''You need to specify either an `images` or `audio` input to process.''') SCREAMING_SNAKE_CASE_ : Any = None if images is not None: SCREAMING_SNAKE_CASE_ : Tuple = self.image_processor(lowercase_ , mask_pixel=lowercase_ , *lowercase_ , **lowercase_) if images_mixed is not None: SCREAMING_SNAKE_CASE_ : Optional[int] = self.image_processor(lowercase_ , is_mixed=lowercase_ , *lowercase_ , **lowercase_) if audio is not None: SCREAMING_SNAKE_CASE_ : Any = self.feature_extractor( lowercase_ , *lowercase_ , sampling_rate=lowercase_ , mask_audio=lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : List[Any] = {} if audio is not None: output_dict.update(lowercase_) if images is not None: output_dict.update(lowercase_) if images_mixed_dict is not None: output_dict.update(lowercase_) return output_dict @property def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = self.image_processor.model_input_names SCREAMING_SNAKE_CASE_ : Dict = self.feature_extractor.model_input_names return list(dict.fromkeys(image_processor_input_names + feature_extractor_input_names))
318
0
"""simple docstring""" import datasets from .evaluate import evaluate UpperCAmelCase_ : List[str] = """\ @article{hendrycks2021cuad, title={CUAD: An Expert-Annotated NLP Dataset for Legal Contract Review}, author={Dan Hendrycks and Collin Burns and Anya Chen and Spencer Ball}, journal={arXiv preprint arXiv:2103.06268}, year={2021} } """ UpperCAmelCase_ : Optional[int] = """ This metric wrap the official scoring script for version 1 of the Contract Understanding Atticus Dataset (CUAD). Contract Understanding Atticus Dataset (CUAD) v1 is a corpus of more than 13,000 labels in 510 commercial legal contracts that have been manually labeled to identify 41 categories of important clauses that lawyers look for when reviewing contracts in connection with corporate transactions. """ UpperCAmelCase_ : Tuple = """ Computes CUAD scores (EM, F1, AUPR, Precision@80%Recall, and Precision@90%Recall). Args: predictions: List of question-answers dictionaries with the following key-values: - 'id': id of the question-answer pair as given in the references (see below) - 'prediction_text': list of possible texts for the answer, as a list of strings depending on a threshold on the confidence probability of each prediction. references: List of question-answers dictionaries with the following key-values: - 'id': id of the question-answer pair (see above), - 'answers': a Dict in the CUAD dataset format { 'text': list of possible texts for the answer, as a list of strings 'answer_start': list of start positions for the answer, as a list of ints } Note that answer_start values are not taken into account to compute the metric. Returns: 'exact_match': Exact match (the normalized answer exactly match the gold answer) 'f1': The F-score of predicted tokens versus the gold answer 'aupr': Area Under the Precision-Recall curve 'prec_at_80_recall': Precision at 80% recall 'prec_at_90_recall': Precision at 90% recall Examples: >>> predictions = [{'prediction_text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.'], 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}] >>> references = [{'answers': {'answer_start': [143, 49], 'text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.']}, 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}] >>> cuad_metric = datasets.load_metric(\"cuad\") >>> results = cuad_metric.compute(predictions=predictions, references=references) >>> print(results) {'exact_match': 100.0, 'f1': 100.0, 'aupr': 0.0, 'prec_at_80_recall': 1.0, 'prec_at_90_recall': 1.0} """ @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class lowerCAmelCase__ ( datasets.Metric ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : Any): '''simple docstring''' return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { '''predictions''': { '''id''': datasets.Value('''string'''), '''prediction_text''': datasets.features.Sequence(datasets.Value('''string''')), }, '''references''': { '''id''': datasets.Value('''string'''), '''answers''': datasets.features.Sequence( { '''text''': datasets.Value('''string'''), '''answer_start''': datasets.Value('''int32'''), }), }, }) , codebase_urls=['''https://www.atticusprojectai.org/cuad'''] , reference_urls=['''https://www.atticusprojectai.org/cuad'''] , ) def _SCREAMING_SNAKE_CASE ( self : Union[str, Any] , lowercase_ : Tuple , lowercase_ : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = {prediction['''id''']: prediction['''prediction_text'''] for prediction in predictions} SCREAMING_SNAKE_CASE_ : int = [ { '''paragraphs''': [ { '''qas''': [ { '''answers''': [{'''text''': answer_text} for answer_text in ref['''answers''']['''text''']], '''id''': ref['''id'''], } for ref in references ] } ] } ] SCREAMING_SNAKE_CASE_ : Dict = evaluate(dataset=lowercase_ , predictions=lowercase_) return score
357
"""simple docstring""" from ...processing_utils import ProcessorMixin class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = "SpeechT5FeatureExtractor" __UpperCamelCase = "SpeechT5Tokenizer" def __init__( self : Any , lowercase_ : Dict , lowercase_ : Optional[Any]): '''simple docstring''' super().__init__(lowercase_ , lowercase_) def __call__( self : List[Any] , *lowercase_ : List[Any] , **lowercase_ : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[str] = kwargs.pop('''audio''' , lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = kwargs.pop('''text''' , lowercase_) SCREAMING_SNAKE_CASE_ : Any = kwargs.pop('''text_target''' , lowercase_) SCREAMING_SNAKE_CASE_ : Dict = kwargs.pop('''audio_target''' , lowercase_) SCREAMING_SNAKE_CASE_ : List[Any] = kwargs.pop('''sampling_rate''' , lowercase_) if audio is not None and text is not None: raise ValueError( '''Cannot process both `audio` and `text` inputs. Did you mean `audio_target` or `text_target`?''') if audio_target is not None and text_target is not None: raise ValueError( '''Cannot process both `audio_target` and `text_target` inputs. Did you mean `audio` or `text`?''') if audio is None and audio_target is None and text is None and text_target is None: raise ValueError( '''You need to specify either an `audio`, `audio_target`, `text`, or `text_target` input to process.''') if audio is not None: SCREAMING_SNAKE_CASE_ : Any = self.feature_extractor(lowercase_ , *lowercase_ , sampling_rate=lowercase_ , **lowercase_) elif text is not None: SCREAMING_SNAKE_CASE_ : Dict = self.tokenizer(lowercase_ , **lowercase_) else: SCREAMING_SNAKE_CASE_ : Any = None if audio_target is not None: SCREAMING_SNAKE_CASE_ : List[Any] = self.feature_extractor(audio_target=lowercase_ , *lowercase_ , sampling_rate=lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = targets['''input_values'''] elif text_target is not None: SCREAMING_SNAKE_CASE_ : int = self.tokenizer(lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : List[Any] = targets['''input_ids'''] else: SCREAMING_SNAKE_CASE_ : int = None if inputs is None: return targets if targets is not None: SCREAMING_SNAKE_CASE_ : Union[str, Any] = labels SCREAMING_SNAKE_CASE_ : Optional[Any] = targets.get('''attention_mask''') if decoder_attention_mask is not None: SCREAMING_SNAKE_CASE_ : Any = decoder_attention_mask return inputs def _SCREAMING_SNAKE_CASE ( self : Tuple , *lowercase_ : Tuple , **lowercase_ : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = kwargs.pop('''input_values''' , lowercase_) SCREAMING_SNAKE_CASE_ : int = kwargs.pop('''input_ids''' , lowercase_) SCREAMING_SNAKE_CASE_ : Dict = kwargs.pop('''labels''' , lowercase_) if input_values is not None and input_ids is not None: raise ValueError('''Cannot process both `input_values` and `input_ids` inputs.''') if input_values is None and input_ids is None and labels is None: raise ValueError( '''You need to specify either an `input_values`, `input_ids`, or `labels` input to be padded.''') if input_values is not None: SCREAMING_SNAKE_CASE_ : Any = self.feature_extractor.pad(lowercase_ , *lowercase_ , **lowercase_) elif input_ids is not None: SCREAMING_SNAKE_CASE_ : Tuple = self.tokenizer.pad(lowercase_ , **lowercase_) else: SCREAMING_SNAKE_CASE_ : List[Any] = None if labels is not None: if "input_ids" in labels or (isinstance(lowercase_ , lowercase_) and "input_ids" in labels[0]): SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.tokenizer.pad(lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : Dict = targets['''input_ids'''] else: SCREAMING_SNAKE_CASE_ : Dict = self.feature_extractor.feature_size SCREAMING_SNAKE_CASE_ : Optional[int] = self.feature_extractor.num_mel_bins SCREAMING_SNAKE_CASE_ : str = self.feature_extractor.pad(lowercase_ , *lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : str = feature_size_hack SCREAMING_SNAKE_CASE_ : Dict = targets['''input_values'''] else: SCREAMING_SNAKE_CASE_ : List[Any] = None if inputs is None: return targets if targets is not None: SCREAMING_SNAKE_CASE_ : Dict = labels SCREAMING_SNAKE_CASE_ : List[str] = targets.get('''attention_mask''') if decoder_attention_mask is not None: SCREAMING_SNAKE_CASE_ : Optional[Any] = decoder_attention_mask return inputs def _SCREAMING_SNAKE_CASE ( self : Optional[Any] , *lowercase_ : Optional[int] , **lowercase_ : Tuple): '''simple docstring''' return self.tokenizer.batch_decode(*lowercase_ , **lowercase_) def _SCREAMING_SNAKE_CASE ( self : List[Any] , *lowercase_ : Dict , **lowercase_ : List[Any]): '''simple docstring''' return self.tokenizer.decode(*lowercase_ , **lowercase_)
318
0
"""simple docstring""" def _A (__a , __a ) -> int: """simple docstring""" return int((input_a, input_a).count(0 ) == 0 ) def _A () -> None: """simple docstring""" assert and_gate(0 , 0 ) == 0 assert and_gate(0 , 1 ) == 0 assert and_gate(1 , 0 ) == 0 assert and_gate(1 , 1 ) == 1 if __name__ == "__main__": test_and_gate() print(and_gate(1, 0)) print(and_gate(0, 0)) print(and_gate(0, 1)) print(and_gate(1, 1))
358
"""simple docstring""" import os from typing import BinaryIO, Optional, Union import numpy as np import pyarrow.parquet as pq from .. import Audio, Dataset, Features, Image, NamedSplit, Value, config from ..features.features import FeatureType, _visit from ..formatting import query_table from ..packaged_modules import _PACKAGED_DATASETS_MODULES from ..packaged_modules.parquet.parquet import Parquet from ..utils import logging from ..utils.typing import NestedDataStructureLike, PathLike from .abc import AbstractDatasetReader def _A (__a ) -> Optional[int]: """simple docstring""" SCREAMING_SNAKE_CASE_ : List[str] = np.inf def set_batch_size(__a ) -> None: nonlocal batch_size if isinstance(__a , __a ): SCREAMING_SNAKE_CASE_ : Tuple = min(__a , config.PARQUET_ROW_GROUP_SIZE_FOR_IMAGE_DATASETS ) elif isinstance(__a , __a ): SCREAMING_SNAKE_CASE_ : int = min(__a , config.PARQUET_ROW_GROUP_SIZE_FOR_AUDIO_DATASETS ) elif isinstance(__a , __a ) and feature.dtype == "binary": SCREAMING_SNAKE_CASE_ : Union[str, Any] = min(__a , config.PARQUET_ROW_GROUP_SIZE_FOR_BINARY_DATASETS ) _visit(__a , __a ) return None if batch_size is np.inf else batch_size class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def __init__( self : Any , lowercase_ : NestedDataStructureLike[PathLike] , lowercase_ : Optional[NamedSplit] = None , lowercase_ : Optional[Features] = None , lowercase_ : str = None , lowercase_ : bool = False , lowercase_ : bool = False , lowercase_ : Optional[int] = None , **lowercase_ : Optional[int] , ): '''simple docstring''' super().__init__( lowercase_ , split=lowercase_ , features=lowercase_ , cache_dir=lowercase_ , keep_in_memory=lowercase_ , streaming=lowercase_ , num_proc=lowercase_ , **lowercase_ , ) SCREAMING_SNAKE_CASE_ : Any = path_or_paths if isinstance(lowercase_ , lowercase_) else {self.split: path_or_paths} SCREAMING_SNAKE_CASE_ : Any = _PACKAGED_DATASETS_MODULES['''parquet'''][1] SCREAMING_SNAKE_CASE_ : Union[str, Any] = Parquet( cache_dir=lowercase_ , data_files=lowercase_ , features=lowercase_ , hash=lowercase_ , **lowercase_ , ) def _SCREAMING_SNAKE_CASE ( self : Tuple): '''simple docstring''' if self.streaming: SCREAMING_SNAKE_CASE_ : str = self.builder.as_streaming_dataset(split=self.split) # Build regular (map-style) dataset else: SCREAMING_SNAKE_CASE_ : Optional[Any] = None SCREAMING_SNAKE_CASE_ : Optional[int] = None SCREAMING_SNAKE_CASE_ : Tuple = None SCREAMING_SNAKE_CASE_ : Dict = None self.builder.download_and_prepare( download_config=lowercase_ , download_mode=lowercase_ , verification_mode=lowercase_ , base_path=lowercase_ , num_proc=self.num_proc , ) SCREAMING_SNAKE_CASE_ : Any = self.builder.as_dataset( split=self.split , verification_mode=lowercase_ , in_memory=self.keep_in_memory) return dataset class lowerCAmelCase__ : '''simple docstring''' def __init__( self : Tuple , lowercase_ : Dataset , lowercase_ : Union[PathLike, BinaryIO] , lowercase_ : Optional[int] = None , **lowercase_ : Dict , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = dataset SCREAMING_SNAKE_CASE_ : Dict = path_or_buf SCREAMING_SNAKE_CASE_ : List[Any] = batch_size or get_writer_batch_size(dataset.features) SCREAMING_SNAKE_CASE_ : Any = parquet_writer_kwargs def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[str] = self.batch_size if self.batch_size else config.DEFAULT_MAX_BATCH_SIZE if isinstance(self.path_or_buf , (str, bytes, os.PathLike)): with open(self.path_or_buf , '''wb+''') as buffer: SCREAMING_SNAKE_CASE_ : Optional[Any] = self._write(file_obj=lowercase_ , batch_size=lowercase_ , **self.parquet_writer_kwargs) else: SCREAMING_SNAKE_CASE_ : str = self._write(file_obj=self.path_or_buf , batch_size=lowercase_ , **self.parquet_writer_kwargs) return written def _SCREAMING_SNAKE_CASE ( self : Tuple , lowercase_ : BinaryIO , lowercase_ : int , **lowercase_ : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = 0 SCREAMING_SNAKE_CASE_ : Optional[int] = parquet_writer_kwargs.pop('''path_or_buf''' , lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = self.dataset.features.arrow_schema SCREAMING_SNAKE_CASE_ : Tuple = pq.ParquetWriter(lowercase_ , schema=lowercase_ , **lowercase_) for offset in logging.tqdm( range(0 , len(self.dataset) , lowercase_) , unit='''ba''' , disable=not logging.is_progress_bar_enabled() , desc='''Creating parquet from Arrow format''' , ): SCREAMING_SNAKE_CASE_ : List[Any] = query_table( table=self.dataset._data , key=slice(lowercase_ , offset + batch_size) , indices=self.dataset._indices if self.dataset._indices is not None else None , ) writer.write_table(lowercase_) written += batch.nbytes writer.close() return written
318
0
"""simple docstring""" from collections import OrderedDict from typing import Mapping from packaging import version from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging UpperCAmelCase_ : Dict = logging.get_logger(__name__) UpperCAmelCase_ : int = { """google/mobilenet_v2_1.4_224""": """https://huggingface.co/google/mobilenet_v2_1.4_224/resolve/main/config.json""", """google/mobilenet_v2_1.0_224""": """https://huggingface.co/google/mobilenet_v2_1.0_224/resolve/main/config.json""", """google/mobilenet_v2_0.75_160""": """https://huggingface.co/google/mobilenet_v2_0.75_160/resolve/main/config.json""", """google/mobilenet_v2_0.35_96""": """https://huggingface.co/google/mobilenet_v2_0.35_96/resolve/main/config.json""", # See all MobileNetV2 models at https://huggingface.co/models?filter=mobilenet_v2 } class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = "mobilenet_v2" def __init__( self : Dict , lowercase_ : Any=3 , lowercase_ : Optional[int]=224 , lowercase_ : Union[str, Any]=1.0 , lowercase_ : List[Any]=8 , lowercase_ : Optional[int]=8 , lowercase_ : str=6 , lowercase_ : Optional[int]=32 , lowercase_ : List[str]=True , lowercase_ : Dict=True , lowercase_ : Optional[int]="relu6" , lowercase_ : Any=True , lowercase_ : Any=0.8 , lowercase_ : Any=0.02 , lowercase_ : List[str]=0.0_01 , lowercase_ : Any=255 , **lowercase_ : List[str] , ): '''simple docstring''' super().__init__(**lowercase_) if depth_multiplier <= 0: raise ValueError('''depth_multiplier must be greater than zero.''') SCREAMING_SNAKE_CASE_ : List[Any] = num_channels SCREAMING_SNAKE_CASE_ : Dict = image_size SCREAMING_SNAKE_CASE_ : Dict = depth_multiplier SCREAMING_SNAKE_CASE_ : Optional[int] = depth_divisible_by SCREAMING_SNAKE_CASE_ : List[Any] = min_depth SCREAMING_SNAKE_CASE_ : Optional[int] = expand_ratio SCREAMING_SNAKE_CASE_ : int = output_stride SCREAMING_SNAKE_CASE_ : Optional[int] = first_layer_is_expansion SCREAMING_SNAKE_CASE_ : List[str] = finegrained_output SCREAMING_SNAKE_CASE_ : Optional[Any] = hidden_act SCREAMING_SNAKE_CASE_ : List[Any] = tf_padding SCREAMING_SNAKE_CASE_ : Tuple = classifier_dropout_prob SCREAMING_SNAKE_CASE_ : List[str] = initializer_range SCREAMING_SNAKE_CASE_ : Union[str, Any] = layer_norm_eps SCREAMING_SNAKE_CASE_ : Union[str, Any] = semantic_loss_ignore_index class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = version.parse("1.11" ) @property def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' return OrderedDict([('''pixel_values''', {0: '''batch'''})]) @property def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' if self.task == "image-classification": return OrderedDict([('''logits''', {0: '''batch'''})]) else: return OrderedDict([('''last_hidden_state''', {0: '''batch'''}), ('''pooler_output''', {0: '''batch'''})]) @property def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' return 1e-4
359
"""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() UpperCAmelCase_ : str = logging.get_logger(__name__) UpperCAmelCase_ : Optional[Any] = ["""model.decoder.embed_positions.weights"""] def _A (__a ) -> Dict: """simple docstring""" if "emb" in name: SCREAMING_SNAKE_CASE_ : Optional[int] = name.replace('''emb''' , '''model.decoder.embed_tokens''' ) if "transformer" in name: SCREAMING_SNAKE_CASE_ : Tuple = name.replace('''transformer''' , '''model.decoder''' ) if "cross_attention" in name: SCREAMING_SNAKE_CASE_ : str = name.replace('''cross_attention''' , '''encoder_attn''' ) if "linear1" in name: SCREAMING_SNAKE_CASE_ : Optional[int] = name.replace('''linear1''' , '''fc1''' ) if "linear2" in name: SCREAMING_SNAKE_CASE_ : str = name.replace('''linear2''' , '''fc2''' ) if "norm1" in name: SCREAMING_SNAKE_CASE_ : Any = name.replace('''norm1''' , '''self_attn_layer_norm''' ) if "norm_cross" in name: SCREAMING_SNAKE_CASE_ : List[str] = name.replace('''norm_cross''' , '''encoder_attn_layer_norm''' ) if "norm2" in name: SCREAMING_SNAKE_CASE_ : Tuple = name.replace('''norm2''' , '''final_layer_norm''' ) if "out_norm" in name: SCREAMING_SNAKE_CASE_ : List[str] = name.replace('''out_norm''' , '''model.decoder.layer_norm''' ) if "linears" in name: SCREAMING_SNAKE_CASE_ : Dict = name.replace('''linears''' , '''lm_heads''' ) if "condition_provider.conditioners.description.output_proj" in name: SCREAMING_SNAKE_CASE_ : List[str] = name.replace('''condition_provider.conditioners.description.output_proj''' , '''enc_to_dec_proj''' ) return name def _A (__a , __a ) -> Tuple[Dict, Dict]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Union[str, Any] = list(state_dict.keys() ) SCREAMING_SNAKE_CASE_ : int = {} for key in keys: SCREAMING_SNAKE_CASE_ : int = state_dict.pop(__a ) SCREAMING_SNAKE_CASE_ : int = rename_keys(__a ) if "in_proj_weight" in key: # split fused qkv proj SCREAMING_SNAKE_CASE_ : List[str] = val[:hidden_size, :] SCREAMING_SNAKE_CASE_ : List[str] = val[hidden_size : 2 * hidden_size, :] SCREAMING_SNAKE_CASE_ : Optional[Any] = val[-hidden_size:, :] elif "enc_to_dec_proj" in key: SCREAMING_SNAKE_CASE_ : int = val else: SCREAMING_SNAKE_CASE_ : Any = val return state_dict, enc_dec_proj_state_dict def _A (__a ) -> MusicgenDecoderConfig: """simple docstring""" if checkpoint == "small": # default config values SCREAMING_SNAKE_CASE_ : Optional[int] = 10_24 SCREAMING_SNAKE_CASE_ : Tuple = 24 SCREAMING_SNAKE_CASE_ : Optional[Any] = 16 elif checkpoint == "medium": SCREAMING_SNAKE_CASE_ : List[str] = 15_36 SCREAMING_SNAKE_CASE_ : Optional[int] = 48 SCREAMING_SNAKE_CASE_ : Optional[int] = 24 elif checkpoint == "large": SCREAMING_SNAKE_CASE_ : Optional[Any] = 20_48 SCREAMING_SNAKE_CASE_ : Optional[int] = 48 SCREAMING_SNAKE_CASE_ : int = 32 else: raise ValueError(f'Checkpoint should be one of `[\'small\', \'medium\', \'large\']`, got {checkpoint}.' ) SCREAMING_SNAKE_CASE_ : List[Any] = MusicgenDecoderConfig( hidden_size=__a , ffn_dim=hidden_size * 4 , num_hidden_layers=__a , num_attention_heads=__a , ) return config @torch.no_grad() def _A (__a , __a=None , __a=None , __a="cpu" ) -> List[str]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Any = MusicGen.get_pretrained(__a , device=__a ) SCREAMING_SNAKE_CASE_ : Dict = decoder_config_from_checkpoint(__a ) SCREAMING_SNAKE_CASE_ : Optional[Any] = fairseq_model.lm.state_dict() SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : int = rename_state_dict( __a , hidden_size=decoder_config.hidden_size ) SCREAMING_SNAKE_CASE_ : Optional[Any] = TaEncoderModel.from_pretrained('''t5-base''' ) SCREAMING_SNAKE_CASE_ : List[str] = EncodecModel.from_pretrained('''facebook/encodec_32khz''' ) SCREAMING_SNAKE_CASE_ : int = MusicgenForCausalLM(__a ).eval() # load all decoder weights - expect that we'll be missing embeddings and enc-dec projection SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : List[str] = decoder.load_state_dict(__a , strict=__a ) for key in missing_keys.copy(): if key.startswith(('''text_encoder''', '''audio_encoder''') ) or key in EXPECTED_MISSING_KEYS: missing_keys.remove(__a ) if len(__a ) > 0: raise ValueError(f'Missing key(s) in state_dict: {missing_keys}' ) if len(__a ) > 0: raise ValueError(f'Unexpected key(s) in state_dict: {unexpected_keys}' ) # init the composite model SCREAMING_SNAKE_CASE_ : str = MusicgenForConditionalGeneration(text_encoder=__a , audio_encoder=__a , decoder=__a ) # load the pre-trained enc-dec projection (from the decoder state dict) model.enc_to_dec_proj.load_state_dict(__a ) # check we can do a forward pass SCREAMING_SNAKE_CASE_ : Dict = torch.arange(0 , 8 , dtype=torch.long ).reshape(2 , -1 ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = input_ids.reshape(2 * 4 , -1 ) with torch.no_grad(): SCREAMING_SNAKE_CASE_ : List[Any] = model(input_ids=__a , decoder_input_ids=__a ).logits if logits.shape != (8, 1, 20_48): raise ValueError('''Incorrect shape for logits''' ) # now construct the processor SCREAMING_SNAKE_CASE_ : str = AutoTokenizer.from_pretrained('''t5-base''' ) SCREAMING_SNAKE_CASE_ : str = AutoFeatureExtractor.from_pretrained('''facebook/encodec_32khz''' , padding_side='''left''' ) SCREAMING_SNAKE_CASE_ : Tuple = MusicgenProcessor(feature_extractor=__a , tokenizer=__a ) # set the appropriate bos/pad token ids SCREAMING_SNAKE_CASE_ : str = 20_48 SCREAMING_SNAKE_CASE_ : List[Any] = 20_48 # set other default generation config params SCREAMING_SNAKE_CASE_ : int = int(30 * audio_encoder.config.frame_rate ) SCREAMING_SNAKE_CASE_ : str = True SCREAMING_SNAKE_CASE_ : Optional[Any] = 3.0 if pytorch_dump_folder is not None: Path(__a ).mkdir(exist_ok=__a ) logger.info(f'Saving model {checkpoint} to {pytorch_dump_folder}' ) model.save_pretrained(__a ) processor.save_pretrained(__a ) if repo_id: logger.info(f'Pushing model {checkpoint} to {repo_id}' ) model.push_to_hub(__a ) processor.push_to_hub(__a ) if __name__ == "__main__": UpperCAmelCase_ : Dict = 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.""" ) UpperCAmelCase_ : Dict = parser.parse_args() convert_musicgen_checkpoint(args.checkpoint, args.pytorch_dump_folder, args.push_to_hub)
318
0
from __future__ import annotations from collections.abc import Callable def _A (__a , __a , __a , __a = 1_00 , ) -> float: """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[int] = x_start SCREAMING_SNAKE_CASE_ : Any = fnc(__a ) SCREAMING_SNAKE_CASE_ : Optional[Any] = 0.0 for _ in range(__a ): # Approximates small segments of curve as linear and solve # for trapezoidal area SCREAMING_SNAKE_CASE_ : Any = (x_end - x_start) / steps + xa SCREAMING_SNAKE_CASE_ : Optional[int] = fnc(__a ) area += abs(fxa + fxa ) * (xa - xa) / 2 # Increment step SCREAMING_SNAKE_CASE_ : str = xa SCREAMING_SNAKE_CASE_ : Any = fxa return area if __name__ == "__main__": def _A (__a ) -> List[Any]: """simple docstring""" return x**3 + x**2 print("""f(x) = x^3 + x^2""") print("""The area between the curve, x = -5, x = 5 and the x axis is:""") UpperCAmelCase_ : int = 10 while i <= 100000: print(f'''with {i} steps: {trapezoidal_area(f, -5, 5, i)}''') i *= 10
360
"""simple docstring""" from pathlib import Path import numpy as np from PIL import Image def _A (__a ) -> np.ndarray: """simple docstring""" SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Optional[int] = rgb[:, :, 0], rgb[:, :, 1], rgb[:, :, 2] return 0.29_89 * r + 0.58_70 * g + 0.11_40 * b def _A (__a ) -> np.ndarray: """simple docstring""" return (gray > 1_27) & (gray <= 2_55) def _A (__a , __a ) -> np.ndarray: """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[Any] = np.zeros_like(__a ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = np.zeros( (image.shape[0] + kernel.shape[0] - 1, image.shape[1] + kernel.shape[1] - 1) ) # Copy image to padded image SCREAMING_SNAKE_CASE_ : Union[str, Any] = image # Iterate over image & apply kernel for x in range(image.shape[1] ): for y in range(image.shape[0] ): SCREAMING_SNAKE_CASE_ : Optional[Any] = ( kernel * image_padded[y : y + kernel.shape[0], x : x + kernel.shape[1]] ).sum() SCREAMING_SNAKE_CASE_ : Any = int(summation > 0 ) return output if __name__ == "__main__": # read original image UpperCAmelCase_ : Dict = Path(__file__).resolve().parent / """image_data""" / """lena.jpg""" UpperCAmelCase_ : List[Any] = np.array(Image.open(lena_path)) # kernel to be applied UpperCAmelCase_ : Any = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]]) UpperCAmelCase_ : Tuple = dilation(gray_to_binary(rgb_to_gray(lena)), structuring_element) # Save the output image UpperCAmelCase_ : List[str] = Image.fromarray(output).convert("""RGB""") pil_img.save("""result_dilation.png""")
318
0
"""simple docstring""" import argparse from torch import nn # transformers_old should correspond to branch `save_old_prophetnet_model_structure` here # original prophetnet_checkpoints are saved under `patrickvonplaten/..._old` respectively from transformers_old.modeling_prophetnet import ( ProphetNetForConditionalGeneration as ProphetNetForConditionalGenerationOld, ) from transformers_old.modeling_xlm_prophetnet import ( XLMProphetNetForConditionalGeneration as XLMProphetNetForConditionalGenerationOld, ) from transformers import ProphetNetForConditionalGeneration, XLMProphetNetForConditionalGeneration, logging UpperCAmelCase_ = logging.get_logger(__name__) logging.set_verbosity_info() def _A (__a , __a ) -> Dict: """simple docstring""" if "xprophetnet" in prophetnet_checkpoint_path: SCREAMING_SNAKE_CASE_ : Optional[int] = XLMProphetNetForConditionalGenerationOld.from_pretrained(__a ) SCREAMING_SNAKE_CASE_ : Optional[int] = XLMProphetNetForConditionalGeneration.from_pretrained( __a , output_loading_info=__a ) else: SCREAMING_SNAKE_CASE_ : Optional[Any] = ProphetNetForConditionalGenerationOld.from_pretrained(__a ) SCREAMING_SNAKE_CASE_ : Dict = ProphetNetForConditionalGeneration.from_pretrained( __a , output_loading_info=__a ) SCREAMING_SNAKE_CASE_ : List[Any] = ['''key_proj''', '''value_proj''', '''query_proj'''] SCREAMING_SNAKE_CASE_ : List[str] = { '''self_attn''': '''ngram_self_attn''', '''cross_attn''': '''encoder_attn''', '''cross_attn_layer_norm''': '''encoder_attn_layer_norm''', '''feed_forward_layer_norm''': '''final_layer_norm''', '''feed_forward''': '''''', '''intermediate''': '''fc1''', '''output''': '''fc2''', '''key_proj''': '''k_proj''', '''query_proj''': '''q_proj''', '''value_proj''': '''v_proj''', '''word_embeddings''': '''embed_tokens''', '''embeddings_layer_norm''': '''emb_layer_norm''', '''relative_pos_embeddings''': '''relative_linear''', '''ngram_embeddings''': '''ngram_input_embed''', '''position_embeddings''': '''embed_positions''', } for key in loading_info["missing_keys"]: SCREAMING_SNAKE_CASE_ : Union[str, Any] = key.split('''.''' ) if attributes[0] == "lm_head": SCREAMING_SNAKE_CASE_ : str = prophet SCREAMING_SNAKE_CASE_ : Dict = prophet_old else: SCREAMING_SNAKE_CASE_ : Union[str, Any] = prophet.prophetnet SCREAMING_SNAKE_CASE_ : Tuple = prophet_old.model SCREAMING_SNAKE_CASE_ : List[Any] = False for attribute in attributes: if attribute in mapping: SCREAMING_SNAKE_CASE_ : List[str] = mapping[attribute] if not hasattr(__a , __a ) and len(__a ) > 0: SCREAMING_SNAKE_CASE_ : str = attribute elif hasattr(__a , __a ): SCREAMING_SNAKE_CASE_ : Tuple = attribute if attribute == "weight": assert old_model.weight.shape == model.weight.shape, "Shapes have to match!" SCREAMING_SNAKE_CASE_ : int = old_model.weight logger.info(f'{attribute} is initialized.' ) SCREAMING_SNAKE_CASE_ : Dict = True break elif attribute == "bias": assert old_model.bias.shape == model.bias.shape, "Shapes have to match!" SCREAMING_SNAKE_CASE_ : Union[str, Any] = old_model.bias logger.info(f'{attribute} is initialized' ) SCREAMING_SNAKE_CASE_ : Optional[int] = True break elif attribute in special_keys and hasattr(__a , '''in_proj_weight''' ): SCREAMING_SNAKE_CASE_ : Dict = old_model.in_proj_weight.shape[0] // 3 SCREAMING_SNAKE_CASE_ : List[Any] = getattr(__a , __a ) param.weight.shape == old_model.in_proj_weight[:embed_dim, :].shape, "Shapes have to match" param.bias.shape == old_model.in_proj_bias[:embed_dim].shape, "Shapes have to match" if attribute == "query_proj": SCREAMING_SNAKE_CASE_ : Dict = nn.Parameter(old_model.in_proj_weight[:embed_dim, :] ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = nn.Parameter(old_model.in_proj_bias[:embed_dim] ) elif attribute == "key_proj": SCREAMING_SNAKE_CASE_ : str = nn.Parameter(old_model.in_proj_weight[embed_dim : 2 * embed_dim, :] ) SCREAMING_SNAKE_CASE_ : str = nn.Parameter(old_model.in_proj_bias[embed_dim : 2 * embed_dim] ) elif attribute == "value_proj": SCREAMING_SNAKE_CASE_ : Dict = nn.Parameter(old_model.in_proj_weight[2 * embed_dim :, :] ) SCREAMING_SNAKE_CASE_ : Dict = nn.Parameter(old_model.in_proj_bias[2 * embed_dim :] ) SCREAMING_SNAKE_CASE_ : Tuple = True break elif attribute == "position_embeddings": assert ( model.position_embeddings.weight.shape[-1] == old_model.embed_positions.weight.shape[-1] ), "Hidden size has to match" assert model.position_embeddings.weight.shape[0] == 5_12, "We want 512 position_embeddings." SCREAMING_SNAKE_CASE_ : int = nn.Parameter(old_model.embed_positions.weight[:5_12, :] ) SCREAMING_SNAKE_CASE_ : List[str] = True break if attribute.isdigit(): SCREAMING_SNAKE_CASE_ : str = model[int(__a )] SCREAMING_SNAKE_CASE_ : Optional[int] = old_model[int(__a )] else: SCREAMING_SNAKE_CASE_ : Tuple = getattr(__a , __a ) if old_attribute == "": SCREAMING_SNAKE_CASE_ : Tuple = old_model else: if not hasattr(__a , __a ): raise ValueError(f'{old_model} does not have {old_attribute}' ) SCREAMING_SNAKE_CASE_ : List[str] = getattr(__a , __a ) if not is_key_init: raise ValueError(f'{key} was not correctly initialized!' ) print(f'Saving model to {pytorch_dump_folder_path}' ) prophet.save_pretrained(__a ) if __name__ == "__main__": UpperCAmelCase_ = argparse.ArgumentParser() # Required parameters parser.add_argument( """--prophetnet_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.""" ) UpperCAmelCase_ = parser.parse_args() convert_prophetnet_checkpoint_to_pytorch(args.prophetnet_checkpoint_path, args.pytorch_dump_folder_path)
361
"""simple docstring""" from collections import defaultdict def _A (__a , __a ) -> bool: """simple docstring""" SCREAMING_SNAKE_CASE_ : Dict = first_str.lower().strip() SCREAMING_SNAKE_CASE_ : List[Any] = second_str.lower().strip() # Remove whitespace SCREAMING_SNAKE_CASE_ : Dict = first_str.replace(''' ''' , '''''' ) SCREAMING_SNAKE_CASE_ : Optional[Any] = second_str.replace(''' ''' , '''''' ) # Strings of different lengths are not anagrams if len(__a ) != len(__a ): return False # Default values for count should be 0 SCREAMING_SNAKE_CASE_ : defaultdict[str, int] = defaultdict(__a ) # For each character in input strings, # increment count in the corresponding for i in range(len(__a ) ): count[first_str[i]] += 1 count[second_str[i]] -= 1 return all(_count == 0 for _count in count.values() ) if __name__ == "__main__": from doctest import testmod testmod() UpperCAmelCase_ : Any = input("""Enter the first string """).strip() UpperCAmelCase_ : Optional[int] = input("""Enter the second string """).strip() UpperCAmelCase_ : Union[str, Any] = check_anagrams(input_a, input_b) print(f'''{input_a} and {input_b} are {'' if status else 'not '}anagrams.''')
318
0
"""simple docstring""" import sys import tempfile import unittest import unittest.mock as mock from pathlib import Path from huggingface_hub import HfFolder, delete_repo from requests.exceptions import HTTPError from transformers import AutoFeatureExtractor, WavaVecaFeatureExtractor from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test sys.path.append(str(Path(__file__).parent.parent / """utils""")) from test_module.custom_feature_extraction import CustomFeatureExtractor # noqa E402 UpperCAmelCase_ : str = get_tests_dir("""fixtures""") class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : Tuple): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = mock.Mock() SCREAMING_SNAKE_CASE_ : List[str] = 500 SCREAMING_SNAKE_CASE_ : str = {} SCREAMING_SNAKE_CASE_ : Any = HTTPError SCREAMING_SNAKE_CASE_ : Optional[int] = {} # Download this model to make sure it's in the cache. SCREAMING_SNAKE_CASE_ : Optional[Any] = WavaVecaFeatureExtractor.from_pretrained('''hf-internal-testing/tiny-random-wav2vec2''') # Under the mock environment we get a 500 error when trying to reach the model. with mock.patch('''requests.Session.request''' , return_value=lowercase_) as mock_head: SCREAMING_SNAKE_CASE_ : int = WavaVecaFeatureExtractor.from_pretrained('''hf-internal-testing/tiny-random-wav2vec2''') # This check we did call the fake head request mock_head.assert_called() def _SCREAMING_SNAKE_CASE ( self : Tuple): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = WavaVecaFeatureExtractor.from_pretrained( '''https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json''') @is_staging_test class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' @classmethod def _SCREAMING_SNAKE_CASE ( cls : Tuple): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = TOKEN HfFolder.save_token(lowercase_) @classmethod def _SCREAMING_SNAKE_CASE ( cls : Any): '''simple docstring''' try: delete_repo(token=cls._token , repo_id='''test-feature-extractor''') except HTTPError: pass try: delete_repo(token=cls._token , repo_id='''valid_org/test-feature-extractor-org''') except HTTPError: pass try: delete_repo(token=cls._token , repo_id='''test-dynamic-feature-extractor''') except HTTPError: pass def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = WavaVecaFeatureExtractor.from_pretrained(lowercase_) feature_extractor.push_to_hub('''test-feature-extractor''' , use_auth_token=self._token) SCREAMING_SNAKE_CASE_ : Dict = WavaVecaFeatureExtractor.from_pretrained(F'{USER}/test-feature-extractor') for k, v in feature_extractor.__dict__.items(): self.assertEqual(lowercase_ , getattr(lowercase_ , lowercase_)) # Reset repo delete_repo(token=self._token , repo_id='''test-feature-extractor''') # Push to hub via save_pretrained with tempfile.TemporaryDirectory() as tmp_dir: feature_extractor.save_pretrained( lowercase_ , repo_id='''test-feature-extractor''' , push_to_hub=lowercase_ , use_auth_token=self._token) SCREAMING_SNAKE_CASE_ : Any = WavaVecaFeatureExtractor.from_pretrained(F'{USER}/test-feature-extractor') for k, v in feature_extractor.__dict__.items(): self.assertEqual(lowercase_ , getattr(lowercase_ , lowercase_)) def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = WavaVecaFeatureExtractor.from_pretrained(lowercase_) feature_extractor.push_to_hub('''valid_org/test-feature-extractor''' , use_auth_token=self._token) SCREAMING_SNAKE_CASE_ : int = WavaVecaFeatureExtractor.from_pretrained('''valid_org/test-feature-extractor''') for k, v in feature_extractor.__dict__.items(): self.assertEqual(lowercase_ , getattr(lowercase_ , lowercase_)) # Reset repo delete_repo(token=self._token , repo_id='''valid_org/test-feature-extractor''') # Push to hub via save_pretrained with tempfile.TemporaryDirectory() as tmp_dir: feature_extractor.save_pretrained( lowercase_ , repo_id='''valid_org/test-feature-extractor-org''' , push_to_hub=lowercase_ , use_auth_token=self._token) SCREAMING_SNAKE_CASE_ : Tuple = WavaVecaFeatureExtractor.from_pretrained('''valid_org/test-feature-extractor-org''') for k, v in feature_extractor.__dict__.items(): self.assertEqual(lowercase_ , getattr(lowercase_ , lowercase_)) def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' CustomFeatureExtractor.register_for_auto_class() SCREAMING_SNAKE_CASE_ : List[str] = CustomFeatureExtractor.from_pretrained(lowercase_) feature_extractor.push_to_hub('''test-dynamic-feature-extractor''' , use_auth_token=self._token) # This has added the proper auto_map field to the config self.assertDictEqual( feature_extractor.auto_map , {'''AutoFeatureExtractor''': '''custom_feature_extraction.CustomFeatureExtractor'''} , ) SCREAMING_SNAKE_CASE_ : Tuple = AutoFeatureExtractor.from_pretrained( F'{USER}/test-dynamic-feature-extractor' , trust_remote_code=lowercase_) # Can't make an isinstance check because the new_feature_extractor is from the CustomFeatureExtractor class of a dynamic module self.assertEqual(new_feature_extractor.__class__.__name__ , '''CustomFeatureExtractor''')
362
"""simple docstring""" import argparse from collections import defaultdict import yaml UpperCAmelCase_ : Optional[Any] = """docs/source/en/_toctree.yml""" def _A (__a ) -> Union[str, Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : str = defaultdict(__a ) for doc in model_doc: counts[doc["local"]] += 1 SCREAMING_SNAKE_CASE_ : List[Any] = [key for key, value in counts.items() if value > 1] SCREAMING_SNAKE_CASE_ : int = [] for duplicate_key in duplicates: SCREAMING_SNAKE_CASE_ : List[str] = list({doc['''title'''] for doc in model_doc if doc['''local'''] == duplicate_key} ) if len(__a ) > 1: raise ValueError( f'{duplicate_key} is present several times in the documentation table of content at ' '''`docs/source/en/_toctree.yml` with different *Title* values. Choose one of those and remove the ''' '''others.''' ) # Only add this once new_doc.append({'''local''': duplicate_key, '''title''': titles[0]} ) # Add none duplicate-keys new_doc.extend([doc for doc in model_doc if counts[doc['''local''']] == 1] ) # Sort return sorted(__a , key=lambda __a : s["title"].lower() ) def _A (__a=False ) -> Tuple: """simple docstring""" with open(__a , encoding='''utf-8''' ) as f: SCREAMING_SNAKE_CASE_ : Dict = yaml.safe_load(f.read() ) # Get to the API doc SCREAMING_SNAKE_CASE_ : Any = 0 while content[api_idx]["title"] != "API": api_idx += 1 SCREAMING_SNAKE_CASE_ : str = content[api_idx]['''sections'''] # Then to the model doc SCREAMING_SNAKE_CASE_ : List[Any] = 0 while api_doc[model_idx]["title"] != "Models": model_idx += 1 SCREAMING_SNAKE_CASE_ : Optional[int] = api_doc[model_idx]['''sections'''] SCREAMING_SNAKE_CASE_ : str = [(idx, section) for idx, section in enumerate(__a ) if '''sections''' in section] SCREAMING_SNAKE_CASE_ : Optional[Any] = False for idx, modality_doc in modalities_docs: SCREAMING_SNAKE_CASE_ : List[str] = modality_doc['''sections'''] SCREAMING_SNAKE_CASE_ : Union[str, Any] = clean_model_doc_toc(__a ) if old_modality_doc != new_modality_doc: SCREAMING_SNAKE_CASE_ : str = True if overwrite: SCREAMING_SNAKE_CASE_ : Optional[int] = new_modality_doc if diff: if overwrite: SCREAMING_SNAKE_CASE_ : List[Any] = model_doc SCREAMING_SNAKE_CASE_ : int = api_doc with open(__a , '''w''' , encoding='''utf-8''' ) as f: f.write(yaml.dump(__a , allow_unicode=__a ) ) else: raise ValueError( '''The model doc part of the table of content is not properly sorted, run `make style` to fix this.''' ) if __name__ == "__main__": UpperCAmelCase_ : List[str] = argparse.ArgumentParser() parser.add_argument("""--fix_and_overwrite""", action="""store_true""", help="""Whether to fix inconsistencies.""") UpperCAmelCase_ : Tuple = parser.parse_args() check_model_doc(args.fix_and_overwrite)
318
0
"""simple docstring""" import json import unittest import numpy as np from huggingface_hub import hf_hub_download from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): import torch if is_vision_available(): from transformers import OneFormerImageProcessor from transformers.models.oneformer.image_processing_oneformer import binary_mask_to_rle from transformers.models.oneformer.modeling_oneformer import OneFormerForUniversalSegmentationOutput if is_vision_available(): from PIL import Image def _A (__a , __a="shi-labs/oneformer_demo" ) -> Union[str, Any]: """simple docstring""" with open(hf_hub_download(__a , __a , repo_type='''dataset''' ) , '''r''' ) as f: SCREAMING_SNAKE_CASE_ : Optional[int] = json.load(__a ) SCREAMING_SNAKE_CASE_ : Dict = {} SCREAMING_SNAKE_CASE_ : Union[str, Any] = [] SCREAMING_SNAKE_CASE_ : List[str] = [] for key, info in class_info.items(): SCREAMING_SNAKE_CASE_ : Optional[Any] = info['''name'''] class_names.append(info['''name'''] ) if info["isthing"]: thing_ids.append(int(__a ) ) SCREAMING_SNAKE_CASE_ : List[str] = thing_ids SCREAMING_SNAKE_CASE_ : List[str] = class_names return metadata class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' def __init__( self : Tuple , lowercase_ : Optional[int] , lowercase_ : str=7 , lowercase_ : Tuple=3 , lowercase_ : Optional[int]=30 , lowercase_ : List[Any]=400 , lowercase_ : Optional[Any]=None , lowercase_ : int=True , lowercase_ : Union[str, Any]=True , lowercase_ : Tuple=[0.5, 0.5, 0.5] , lowercase_ : int=[0.5, 0.5, 0.5] , lowercase_ : Tuple=10 , lowercase_ : Optional[int]=False , lowercase_ : Dict=255 , lowercase_ : List[str]="shi-labs/oneformer_demo" , lowercase_ : Tuple="ade20k_panoptic.json" , lowercase_ : Dict=10 , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = parent SCREAMING_SNAKE_CASE_ : List[Any] = batch_size SCREAMING_SNAKE_CASE_ : str = num_channels SCREAMING_SNAKE_CASE_ : Optional[int] = min_resolution SCREAMING_SNAKE_CASE_ : int = max_resolution SCREAMING_SNAKE_CASE_ : Tuple = do_resize SCREAMING_SNAKE_CASE_ : int = {'''shortest_edge''': 32, '''longest_edge''': 1333} if size is None else size SCREAMING_SNAKE_CASE_ : Dict = do_normalize SCREAMING_SNAKE_CASE_ : Union[str, Any] = image_mean SCREAMING_SNAKE_CASE_ : Any = image_std SCREAMING_SNAKE_CASE_ : Union[str, Any] = class_info_file SCREAMING_SNAKE_CASE_ : int = prepare_metadata(lowercase_ , lowercase_) SCREAMING_SNAKE_CASE_ : int = num_text SCREAMING_SNAKE_CASE_ : Union[str, Any] = repo_path # for the post_process_functions SCREAMING_SNAKE_CASE_ : Any = 2 SCREAMING_SNAKE_CASE_ : Union[str, Any] = 10 SCREAMING_SNAKE_CASE_ : List[str] = 10 SCREAMING_SNAKE_CASE_ : Optional[int] = 3 SCREAMING_SNAKE_CASE_ : Tuple = 4 SCREAMING_SNAKE_CASE_ : int = num_labels SCREAMING_SNAKE_CASE_ : Optional[Any] = do_reduce_labels SCREAMING_SNAKE_CASE_ : Optional[Any] = ignore_index def _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' return { "do_resize": self.do_resize, "size": self.size, "do_normalize": self.do_normalize, "image_mean": self.image_mean, "image_std": self.image_std, "num_labels": self.num_labels, "do_reduce_labels": self.do_reduce_labels, "ignore_index": self.ignore_index, "class_info_file": self.class_info_file, "metadata": self.metadata, "num_text": self.num_text, } def _SCREAMING_SNAKE_CASE ( self : List[Any] , lowercase_ : Union[str, Any] , lowercase_ : List[str]=False): '''simple docstring''' if not batched: SCREAMING_SNAKE_CASE_ : int = image_inputs[0] if isinstance(lowercase_ , Image.Image): SCREAMING_SNAKE_CASE_ : List[str] = image.size else: SCREAMING_SNAKE_CASE_ : List[str] = image.shape[1], image.shape[2] if w < h: SCREAMING_SNAKE_CASE_ : Any = int(self.size['''shortest_edge'''] * h / w) SCREAMING_SNAKE_CASE_ : Optional[int] = self.size['''shortest_edge'''] elif w > h: SCREAMING_SNAKE_CASE_ : List[Any] = self.size['''shortest_edge'''] SCREAMING_SNAKE_CASE_ : Dict = int(self.size['''shortest_edge'''] * w / h) else: SCREAMING_SNAKE_CASE_ : List[str] = self.size['''shortest_edge'''] SCREAMING_SNAKE_CASE_ : int = self.size['''shortest_edge'''] else: SCREAMING_SNAKE_CASE_ : Union[str, Any] = [] for image in image_inputs: SCREAMING_SNAKE_CASE_ : str = self.get_expected_values([image]) expected_values.append((expected_height, expected_width)) SCREAMING_SNAKE_CASE_ : Tuple = max(lowercase_ , key=lambda lowercase_: item[0])[0] SCREAMING_SNAKE_CASE_ : List[Any] = max(lowercase_ , key=lambda lowercase_: item[1])[1] return expected_height, expected_width def _SCREAMING_SNAKE_CASE ( self : Tuple): '''simple docstring''' return OneFormerForUniversalSegmentationOutput( # +1 for null class class_queries_logits=torch.randn((self.batch_size, self.num_queries, self.num_classes + 1)) , masks_queries_logits=torch.randn((self.batch_size, self.num_queries, self.height, self.width)) , ) @require_torch @require_vision class lowerCAmelCase__ ( UpperCAmelCase__ , unittest.TestCase ): '''simple docstring''' __UpperCamelCase = OneFormerImageProcessor if (is_vision_available() and is_torch_available()) else None # only for test_image_processing_common.test_image_proc_to_json_string __UpperCamelCase = image_processing_class def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = OneFormerImageProcessorTester(self) @property def _SCREAMING_SNAKE_CASE ( self : Any): '''simple docstring''' return self.image_processing_tester.prepare_image_processor_dict() def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = self.image_processing_class(**self.image_processor_dict) self.assertTrue(hasattr(lowercase_ , '''image_mean''')) self.assertTrue(hasattr(lowercase_ , '''image_std''')) self.assertTrue(hasattr(lowercase_ , '''do_normalize''')) self.assertTrue(hasattr(lowercase_ , '''do_resize''')) self.assertTrue(hasattr(lowercase_ , '''size''')) self.assertTrue(hasattr(lowercase_ , '''ignore_index''')) self.assertTrue(hasattr(lowercase_ , '''class_info_file''')) self.assertTrue(hasattr(lowercase_ , '''num_text''')) self.assertTrue(hasattr(lowercase_ , '''repo_path''')) self.assertTrue(hasattr(lowercase_ , '''metadata''')) self.assertTrue(hasattr(lowercase_ , '''do_reduce_labels''')) def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' pass def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = self.image_processing_class(**self.image_processor_dict) # create random PIL images SCREAMING_SNAKE_CASE_ : Tuple = prepare_image_inputs(self.image_processing_tester , equal_resolution=lowercase_) for image in image_inputs: self.assertIsInstance(lowercase_ , Image.Image) # Test not batched input SCREAMING_SNAKE_CASE_ : Any = image_processor(image_inputs[0] , ['''semantic'''] , return_tensors='''pt''').pixel_values SCREAMING_SNAKE_CASE_ : Optional[Any] = self.image_processing_tester.get_expected_values(lowercase_) self.assertEqual( encoded_images.shape , (1, self.image_processing_tester.num_channels, expected_height, expected_width) , ) # Test batched SCREAMING_SNAKE_CASE_ : Dict = self.image_processing_tester.get_expected_values(lowercase_ , batched=lowercase_) SCREAMING_SNAKE_CASE_ : List[Any] = image_processor( lowercase_ , ['''semantic'''] * len(lowercase_) , return_tensors='''pt''').pixel_values self.assertEqual( encoded_images.shape , ( self.image_processing_tester.batch_size, self.image_processing_tester.num_channels, expected_height, expected_width, ) , ) def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors SCREAMING_SNAKE_CASE_ : Tuple = prepare_image_inputs(self.image_processing_tester , equal_resolution=lowercase_ , numpify=lowercase_) for image in image_inputs: self.assertIsInstance(lowercase_ , np.ndarray) # Test not batched input SCREAMING_SNAKE_CASE_ : List[str] = image_processor(image_inputs[0] , ['''semantic'''] , return_tensors='''pt''').pixel_values SCREAMING_SNAKE_CASE_ : Dict = self.image_processing_tester.get_expected_values(lowercase_) self.assertEqual( encoded_images.shape , (1, self.image_processing_tester.num_channels, expected_height, expected_width) , ) # Test batched SCREAMING_SNAKE_CASE_ : Dict = self.image_processing_tester.get_expected_values(lowercase_ , batched=lowercase_) SCREAMING_SNAKE_CASE_ : Tuple = image_processor( lowercase_ , ['''semantic'''] * len(lowercase_) , return_tensors='''pt''').pixel_values self.assertEqual( encoded_images.shape , ( self.image_processing_tester.batch_size, self.image_processing_tester.num_channels, expected_height, expected_width, ) , ) def _SCREAMING_SNAKE_CASE ( self : Tuple): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors SCREAMING_SNAKE_CASE_ : List[Any] = prepare_image_inputs(self.image_processing_tester , equal_resolution=lowercase_ , torchify=lowercase_) for image in image_inputs: self.assertIsInstance(lowercase_ , torch.Tensor) # Test not batched input SCREAMING_SNAKE_CASE_ : List[Any] = image_processor(image_inputs[0] , ['''semantic'''] , return_tensors='''pt''').pixel_values SCREAMING_SNAKE_CASE_ : List[Any] = self.image_processing_tester.get_expected_values(lowercase_) self.assertEqual( encoded_images.shape , (1, self.image_processing_tester.num_channels, expected_height, expected_width) , ) # Test batched SCREAMING_SNAKE_CASE_ : Optional[Any] = self.image_processing_tester.get_expected_values(lowercase_ , batched=lowercase_) SCREAMING_SNAKE_CASE_ : List[Any] = image_processor( lowercase_ , ['''semantic'''] * len(lowercase_) , return_tensors='''pt''').pixel_values self.assertEqual( encoded_images.shape , ( self.image_processing_tester.batch_size, self.image_processing_tester.num_channels, expected_height, expected_width, ) , ) def _SCREAMING_SNAKE_CASE ( self : str , lowercase_ : List[str]=False , lowercase_ : Dict=False , lowercase_ : List[Any]="np"): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = self.image_processing_class(**self.image_processor_dict) # prepare image and target SCREAMING_SNAKE_CASE_ : List[str] = self.image_processing_tester.num_labels SCREAMING_SNAKE_CASE_ : List[Any] = None SCREAMING_SNAKE_CASE_ : List[str] = None SCREAMING_SNAKE_CASE_ : Tuple = prepare_image_inputs(self.image_processing_tester , equal_resolution=lowercase_) if with_segmentation_maps: SCREAMING_SNAKE_CASE_ : Union[str, Any] = num_labels if is_instance_map: SCREAMING_SNAKE_CASE_ : Tuple = list(range(lowercase_)) * 2 SCREAMING_SNAKE_CASE_ : Optional[int] = dict(enumerate(lowercase_)) SCREAMING_SNAKE_CASE_ : Dict = [ np.random.randint(0 , high * 2 , (img.size[1], img.size[0])).astype(np.uinta) for img in image_inputs ] if segmentation_type == "pil": SCREAMING_SNAKE_CASE_ : int = [Image.fromarray(lowercase_) for annotation in annotations] SCREAMING_SNAKE_CASE_ : Optional[int] = image_processor( lowercase_ , ['''semantic'''] * len(lowercase_) , lowercase_ , return_tensors='''pt''' , instance_id_to_semantic_id=lowercase_ , pad_and_return_pixel_mask=lowercase_ , ) return inputs def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' pass def _SCREAMING_SNAKE_CASE ( self : Any): '''simple docstring''' def common(lowercase_ : List[str]=False , lowercase_ : Dict=None): SCREAMING_SNAKE_CASE_ : str = self.comm_get_image_processor_inputs( with_segmentation_maps=lowercase_ , is_instance_map=lowercase_ , segmentation_type=lowercase_) SCREAMING_SNAKE_CASE_ : Optional[Any] = inputs['''mask_labels'''] SCREAMING_SNAKE_CASE_ : int = inputs['''class_labels'''] SCREAMING_SNAKE_CASE_ : Union[str, Any] = inputs['''pixel_values'''] SCREAMING_SNAKE_CASE_ : Tuple = inputs['''text_inputs'''] # check the batch_size for mask_label, class_label, text_input in zip(lowercase_ , lowercase_ , lowercase_): self.assertEqual(mask_label.shape[0] , class_label.shape[0]) # this ensure padding has happened self.assertEqual(mask_label.shape[1:] , pixel_values.shape[2:]) self.assertEqual(len(lowercase_) , self.image_processing_tester.num_text) common() common(is_instance_map=lowercase_) common(is_instance_map=lowercase_ , segmentation_type='''pil''') common(is_instance_map=lowercase_ , segmentation_type='''pil''') def _SCREAMING_SNAKE_CASE ( self : Any): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = np.zeros((20, 50)) SCREAMING_SNAKE_CASE_ : Union[str, Any] = 1 SCREAMING_SNAKE_CASE_ : str = 1 SCREAMING_SNAKE_CASE_ : Dict = 1 SCREAMING_SNAKE_CASE_ : Union[str, Any] = binary_mask_to_rle(lowercase_) self.assertEqual(len(lowercase_) , 4) self.assertEqual(rle[0] , 21) self.assertEqual(rle[1] , 45) def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = self.image_processing_class( num_labels=self.image_processing_tester.num_classes , max_seq_length=77 , task_seq_length=77 , class_info_file='''ade20k_panoptic.json''' , num_text=self.image_processing_tester.num_text , repo_path='''shi-labs/oneformer_demo''' , ) SCREAMING_SNAKE_CASE_ : str = self.image_processing_tester.get_fake_oneformer_outputs() SCREAMING_SNAKE_CASE_ : Dict = fature_extractor.post_process_semantic_segmentation(lowercase_) self.assertEqual(len(lowercase_) , self.image_processing_tester.batch_size) self.assertEqual( segmentation[0].shape , ( self.image_processing_tester.height, self.image_processing_tester.width, ) , ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = [(1, 4) for i in range(self.image_processing_tester.batch_size)] SCREAMING_SNAKE_CASE_ : str = fature_extractor.post_process_semantic_segmentation(lowercase_ , target_sizes=lowercase_) self.assertEqual(segmentation[0].shape , target_sizes[0]) def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = self.image_processing_class( num_labels=self.image_processing_tester.num_classes , max_seq_length=77 , task_seq_length=77 , class_info_file='''ade20k_panoptic.json''' , num_text=self.image_processing_tester.num_text , repo_path='''shi-labs/oneformer_demo''' , ) SCREAMING_SNAKE_CASE_ : Any = self.image_processing_tester.get_fake_oneformer_outputs() SCREAMING_SNAKE_CASE_ : str = image_processor.post_process_instance_segmentation(lowercase_ , threshold=0) self.assertTrue(len(lowercase_) == self.image_processing_tester.batch_size) for el in segmentation: self.assertTrue('''segmentation''' in el) self.assertTrue('''segments_info''' in el) self.assertEqual(type(el['''segments_info''']) , lowercase_) self.assertEqual( el['''segmentation'''].shape , (self.image_processing_tester.height, self.image_processing_tester.width)) def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = self.image_processing_class( num_labels=self.image_processing_tester.num_classes , max_seq_length=77 , task_seq_length=77 , class_info_file='''ade20k_panoptic.json''' , num_text=self.image_processing_tester.num_text , repo_path='''shi-labs/oneformer_demo''' , ) SCREAMING_SNAKE_CASE_ : List[Any] = self.image_processing_tester.get_fake_oneformer_outputs() SCREAMING_SNAKE_CASE_ : Tuple = image_processor.post_process_panoptic_segmentation(lowercase_ , threshold=0) self.assertTrue(len(lowercase_) == self.image_processing_tester.batch_size) for el in segmentation: self.assertTrue('''segmentation''' in el) self.assertTrue('''segments_info''' in el) self.assertEqual(type(el['''segments_info''']) , lowercase_) self.assertEqual( el['''segmentation'''].shape , (self.image_processing_tester.height, self.image_processing_tester.width))
363
"""simple docstring""" from ...utils import ( OptionalDependencyNotAvailable, is_torch_available, is_transformers_available, is_transformers_version, ) try: if not (is_transformers_available() and is_torch_available() and is_transformers_version(""">=""", """4.25.0""")): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ...utils.dummy_torch_and_transformers_objects import ( VersatileDiffusionDualGuidedPipeline, VersatileDiffusionImageVariationPipeline, VersatileDiffusionPipeline, VersatileDiffusionTextToImagePipeline, ) else: from .modeling_text_unet import UNetFlatConditionModel from .pipeline_versatile_diffusion import VersatileDiffusionPipeline from .pipeline_versatile_diffusion_dual_guided import VersatileDiffusionDualGuidedPipeline from .pipeline_versatile_diffusion_image_variation import VersatileDiffusionImageVariationPipeline from .pipeline_versatile_diffusion_text_to_image import VersatileDiffusionTextToImagePipeline
318
0
"""simple docstring""" import sys import webbrowser import requests from bsa import BeautifulSoup from fake_useragent import UserAgent if __name__ == "__main__": print("""Googling.....""") UpperCAmelCase_ : Any = """https://www.google.com/search?q=""" + """ """.join(sys.argv[1:]) UpperCAmelCase_ : Dict = requests.get(url, headers={"""UserAgent""": UserAgent().random}) # res.raise_for_status() with open("""project1a.html""", """wb""") as out_file: # only for knowing the class for data in res.iter_content(10000): out_file.write(data) UpperCAmelCase_ : Optional[Any] = BeautifulSoup(res.text, """html.parser""") UpperCAmelCase_ : List[Any] = list(soup.select(""".eZt8xd"""))[:5] print(len(links)) for link in links: if link.text == "Maps": webbrowser.open(link.get("""href""")) else: webbrowser.open(f'''https://google.com{link.get('href')}''')
364
"""simple docstring""" from __future__ import annotations UpperCAmelCase_ : List[str] = list[list[int]] # assigning initial values to the grid UpperCAmelCase_ : Matrix = [ [3, 0, 6, 5, 0, 8, 4, 0, 0], [5, 2, 0, 0, 0, 0, 0, 0, 0], [0, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] # a grid with no solution UpperCAmelCase_ : Matrix = [ [5, 0, 6, 5, 0, 8, 4, 0, 3], [5, 2, 0, 0, 0, 0, 0, 0, 2], [1, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] def _A (__a , __a , __a , __a ) -> bool: """simple docstring""" for i in range(9 ): if grid[row][i] == n or grid[i][column] == n: return False for i in range(3 ): for j in range(3 ): if grid[(row - row % 3) + i][(column - column % 3) + j] == n: return False return True def _A (__a ) -> tuple[int, int] | None: """simple docstring""" for i in range(9 ): for j in range(9 ): if grid[i][j] == 0: return i, j return None def _A (__a ) -> Matrix | None: """simple docstring""" if location := find_empty_location(__a ): SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Dict = location else: # If the location is ``None``, then the grid is solved. return grid for digit in range(1 , 10 ): if is_safe(__a , __a , __a , __a ): SCREAMING_SNAKE_CASE_ : Tuple = digit if sudoku(__a ) is not None: return grid SCREAMING_SNAKE_CASE_ : Any = 0 return None def _A (__a ) -> None: """simple docstring""" for row in grid: for cell in row: print(__a , end=''' ''' ) print() if __name__ == "__main__": # make a copy of grid so that you can compare with the unmodified grid for example_grid in (initial_grid, no_solution): print("""\nExample grid:\n""" + """=""" * 20) print_solution(example_grid) print("""\nExample grid solution:""") UpperCAmelCase_ : str = sudoku(example_grid) if solution is not None: print_solution(solution) else: print("""Cannot find a solution.""")
318
0
"""simple docstring""" import inspect import unittest from huggingface_hub import hf_hub_download from transformers import ASTConfig from transformers.testing_utils import require_torch, require_torchaudio, slow, torch_device from transformers.utils import cached_property, is_torch_available, is_torchaudio_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 ASTForAudioClassification, ASTModel from transformers.models.audio_spectrogram_transformer.modeling_audio_spectrogram_transformer import ( AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, ) if is_torchaudio_available(): import torchaudio from transformers import ASTFeatureExtractor class lowerCAmelCase__ : '''simple docstring''' def __init__( self : str , lowercase_ : Any , lowercase_ : List[Any]=13 , lowercase_ : List[str]=2 , lowercase_ : Optional[int]=24 , lowercase_ : List[Any]=16 , lowercase_ : Dict=True , lowercase_ : Dict=True , lowercase_ : Tuple=32 , lowercase_ : Tuple=5 , lowercase_ : Optional[Any]=4 , lowercase_ : Dict=37 , lowercase_ : int="gelu" , lowercase_ : Tuple=0.1 , lowercase_ : Optional[int]=0.1 , lowercase_ : Tuple=10 , lowercase_ : str=0.02 , lowercase_ : Optional[Any]=None , lowercase_ : List[str]=2 , lowercase_ : List[Any]=2 , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = parent SCREAMING_SNAKE_CASE_ : Tuple = batch_size SCREAMING_SNAKE_CASE_ : Tuple = patch_size SCREAMING_SNAKE_CASE_ : List[Any] = max_length SCREAMING_SNAKE_CASE_ : Dict = num_mel_bins SCREAMING_SNAKE_CASE_ : Dict = is_training SCREAMING_SNAKE_CASE_ : Dict = use_labels SCREAMING_SNAKE_CASE_ : Dict = hidden_size SCREAMING_SNAKE_CASE_ : Union[str, Any] = num_hidden_layers SCREAMING_SNAKE_CASE_ : List[str] = num_attention_heads SCREAMING_SNAKE_CASE_ : Tuple = intermediate_size SCREAMING_SNAKE_CASE_ : Dict = hidden_act SCREAMING_SNAKE_CASE_ : Any = hidden_dropout_prob SCREAMING_SNAKE_CASE_ : List[Any] = attention_probs_dropout_prob SCREAMING_SNAKE_CASE_ : Union[str, Any] = type_sequence_label_size SCREAMING_SNAKE_CASE_ : str = initializer_range SCREAMING_SNAKE_CASE_ : Union[str, Any] = scope SCREAMING_SNAKE_CASE_ : int = frequency_stride SCREAMING_SNAKE_CASE_ : Tuple = time_stride # in AST, the seq length equals the number of patches + 2 (we add 2 for the [CLS] and distillation tokens) SCREAMING_SNAKE_CASE_ : int = (self.num_mel_bins - self.patch_size) // self.frequency_stride + 1 SCREAMING_SNAKE_CASE_ : Dict = (self.max_length - self.patch_size) // self.time_stride + 1 SCREAMING_SNAKE_CASE_ : Any = frequency_out_dimension * time_out_dimension SCREAMING_SNAKE_CASE_ : Optional[int] = num_patches + 2 def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = floats_tensor([self.batch_size, self.max_length, self.num_mel_bins]) SCREAMING_SNAKE_CASE_ : int = None if self.use_labels: SCREAMING_SNAKE_CASE_ : int = ids_tensor([self.batch_size] , self.type_sequence_label_size) SCREAMING_SNAKE_CASE_ : Optional[Any] = self.get_config() return config, input_values, labels def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' return ASTConfig( patch_size=self.patch_size , max_length=self.max_length , num_mel_bins=self.num_mel_bins , 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=lowercase_ , initializer_range=self.initializer_range , frequency_stride=self.frequency_stride , time_stride=self.time_stride , ) def _SCREAMING_SNAKE_CASE ( self : Dict , lowercase_ : int , lowercase_ : Optional[Any] , lowercase_ : Any): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = ASTModel(config=lowercase_) model.to(lowercase_) model.eval() SCREAMING_SNAKE_CASE_ : List[Any] = model(lowercase_) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size)) def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = self.prepare_config_and_inputs() ( SCREAMING_SNAKE_CASE_ ) : str = config_and_inputs SCREAMING_SNAKE_CASE_ : Optional[Any] = {'''input_values''': input_values} return config, inputs_dict @require_torch class lowerCAmelCase__ ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): '''simple docstring''' __UpperCamelCase = ( ( ASTModel, ASTForAudioClassification, ) if is_torch_available() else () ) __UpperCamelCase = ( {"audio-classification": ASTForAudioClassification, "feature-extraction": ASTModel} if is_torch_available() else {} ) __UpperCamelCase = False __UpperCamelCase = False __UpperCamelCase = False __UpperCamelCase = False def _SCREAMING_SNAKE_CASE ( self : Optional[int] , lowercase_ : Union[str, Any] , lowercase_ : Tuple , lowercase_ : Any , lowercase_ : Optional[int] , lowercase_ : List[str]): '''simple docstring''' if pipeline_test_casse_name == "AudioClassificationPipelineTests": return True return False def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = ASTModelTester(self) SCREAMING_SNAKE_CASE_ : str = ConfigTester(self , config_class=lowercase_ , has_text_modality=lowercase_ , hidden_size=37) def _SCREAMING_SNAKE_CASE ( self : Any): '''simple docstring''' self.config_tester.run_common_tests() @unittest.skip(reason='''AST does not use inputs_embeds''') def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' pass def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: SCREAMING_SNAKE_CASE_ : int = model_class(lowercase_) self.assertIsInstance(model.get_input_embeddings() , (nn.Module)) SCREAMING_SNAKE_CASE_ : int = model.get_output_embeddings() self.assertTrue(x is None or isinstance(lowercase_ , nn.Linear)) def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: SCREAMING_SNAKE_CASE_ : Dict = model_class(lowercase_) SCREAMING_SNAKE_CASE_ : Any = inspect.signature(model.forward) # signature.parameters is an OrderedDict => so arg_names order is deterministic SCREAMING_SNAKE_CASE_ : str = [*signature.parameters.keys()] SCREAMING_SNAKE_CASE_ : List[Any] = ['''input_values'''] self.assertListEqual(arg_names[:1] , lowercase_) def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*lowercase_) @slow def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' for model_name in AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: SCREAMING_SNAKE_CASE_ : Dict = ASTModel.from_pretrained(lowercase_) self.assertIsNotNone(lowercase_) def _A () -> Optional[int]: """simple docstring""" SCREAMING_SNAKE_CASE_ : int = hf_hub_download( repo_id='''nielsr/audio-spectogram-transformer-checkpoint''' , filename='''sample_audio.flac''' , repo_type='''dataset''' ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = torchaudio.load(__a ) return audio, sampling_rate @require_torch @require_torchaudio class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' @cached_property def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' return ( ASTFeatureExtractor.from_pretrained('''MIT/ast-finetuned-audioset-10-10-0.4593''') if is_torchaudio_available() else None ) @slow def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.default_feature_extractor SCREAMING_SNAKE_CASE_ : Optional[Any] = ASTForAudioClassification.from_pretrained('''MIT/ast-finetuned-audioset-10-10-0.4593''').to(lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = self.default_feature_extractor SCREAMING_SNAKE_CASE_ : str = prepare_audio() SCREAMING_SNAKE_CASE_ : int = audio.squeeze().numpy() SCREAMING_SNAKE_CASE_ : str = feature_extractor(lowercase_ , sampling_rate=lowercase_ , return_tensors='''pt''').to(lowercase_) # forward pass with torch.no_grad(): SCREAMING_SNAKE_CASE_ : Optional[int] = model(**lowercase_) # verify the logits SCREAMING_SNAKE_CASE_ : List[Any] = torch.Size((1, 527)) self.assertEqual(outputs.logits.shape , lowercase_) SCREAMING_SNAKE_CASE_ : Optional[Any] = torch.tensor([-0.87_60, -7.00_42, -8.66_02]).to(lowercase_) self.assertTrue(torch.allclose(outputs.logits[0, :3] , lowercase_ , atol=1e-4))
365
"""simple docstring""" from itertools import permutations def _A (__a ) -> bool: """simple docstring""" if num[3] % 2 != 0: return False if (num[2] + num[3] + num[4]) % 3 != 0: return False if num[5] % 5 != 0: return False SCREAMING_SNAKE_CASE_ : List[str] = [7, 11, 13, 17] for i, test in enumerate(__a ): if (num[i + 4] * 1_00 + num[i + 5] * 10 + num[i + 6]) % test != 0: return False return True def _A (__a = 10 ) -> int: """simple docstring""" return sum( int(''''''.join(map(__a , __a ) ) ) for num in permutations(range(__a ) ) if is_substring_divisible(__a ) ) if __name__ == "__main__": print(f'''{solution() = }''')
318
0
"""simple docstring""" import os from shutil import copyfile from typing import List, Optional, Tuple from ...tokenization_utils import AddedToken from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import is_sentencepiece_available, logging if is_sentencepiece_available(): from .tokenization_camembert import CamembertTokenizer else: UpperCAmelCase_ : Any = None UpperCAmelCase_ : List[Any] = logging.get_logger(__name__) UpperCAmelCase_ : int = {"""vocab_file""": """sentencepiece.bpe.model""", """tokenizer_file""": """tokenizer.json"""} UpperCAmelCase_ : int = { """vocab_file""": { """camembert-base""": """https://huggingface.co/camembert-base/resolve/main/sentencepiece.bpe.model""", }, """tokenizer_file""": { """camembert-base""": """https://huggingface.co/camembert-base/resolve/main/tokenizer.json""", }, } UpperCAmelCase_ : Optional[int] = { """camembert-base""": 512, } UpperCAmelCase_ : Union[str, Any] = """▁""" class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = VOCAB_FILES_NAMES __UpperCamelCase = PRETRAINED_VOCAB_FILES_MAP __UpperCamelCase = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES __UpperCamelCase = ["input_ids", "attention_mask"] __UpperCamelCase = CamembertTokenizer def __init__( self : Dict , lowercase_ : Dict=None , lowercase_ : int=None , lowercase_ : Union[str, Any]="<s>" , lowercase_ : Dict="</s>" , lowercase_ : str="</s>" , lowercase_ : Dict="<s>" , lowercase_ : Union[str, Any]="<unk>" , lowercase_ : Dict="<pad>" , lowercase_ : Optional[int]="<mask>" , lowercase_ : int=["<s>NOTUSED", "</s>NOTUSED"] , **lowercase_ : List[Any] , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = AddedToken(lowercase_ , lstrip=lowercase_ , rstrip=lowercase_) if isinstance(lowercase_ , lowercase_) else mask_token super().__init__( lowercase_ , tokenizer_file=lowercase_ , bos_token=lowercase_ , eos_token=lowercase_ , sep_token=lowercase_ , cls_token=lowercase_ , unk_token=lowercase_ , pad_token=lowercase_ , mask_token=lowercase_ , additional_special_tokens=lowercase_ , **lowercase_ , ) SCREAMING_SNAKE_CASE_ : List[Any] = vocab_file SCREAMING_SNAKE_CASE_ : List[Any] = False if not self.vocab_file else True def _SCREAMING_SNAKE_CASE ( self : Tuple , lowercase_ : List[int] , lowercase_ : Optional[List[int]] = None): '''simple docstring''' if token_ids_a is None: return [self.cls_token_id] + token_ids_a + [self.sep_token_id] SCREAMING_SNAKE_CASE_ : str = [self.cls_token_id] SCREAMING_SNAKE_CASE_ : Dict = [self.sep_token_id] return cls + token_ids_a + sep + sep + token_ids_a + sep def _SCREAMING_SNAKE_CASE ( self : List[Any] , lowercase_ : List[int] , lowercase_ : Optional[List[int]] = None): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = [self.sep_token_id] SCREAMING_SNAKE_CASE_ : Dict = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep) * [0] return len(cls + token_ids_a + sep + sep + token_ids_a + sep) * [0] def _SCREAMING_SNAKE_CASE ( self : Optional[int] , lowercase_ : str , lowercase_ : Optional[str] = None): '''simple docstring''' if not self.can_save_slow_tokenizer: raise ValueError( '''Your fast tokenizer does not have the necessary information to save the vocabulary for a slow ''' '''tokenizer.''') if not os.path.isdir(lowercase_): logger.error(F'Vocabulary path ({save_directory}) should be a directory') return SCREAMING_SNAKE_CASE_ : Any = os.path.join( lowercase_ , (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']) if os.path.abspath(self.vocab_file) != os.path.abspath(lowercase_): copyfile(self.vocab_file , lowercase_) return (out_vocab_file,)
366
"""simple docstring""" UpperCAmelCase_ : List[Any] = 9.8_0_6_6_5 def _A (__a , __a , __a = g ) -> float: """simple docstring""" if fluid_density <= 0: raise ValueError('''Impossible fluid density''' ) if volume < 0: raise ValueError('''Impossible Object volume''' ) if gravity <= 0: raise ValueError('''Impossible Gravity''' ) return fluid_density * gravity * volume if __name__ == "__main__": import doctest # run doctest doctest.testmod()
318
0
"""simple docstring""" class lowerCAmelCase__ : '''simple docstring''' def __init__( self : Any , lowercase_ : Union[str, Any] , lowercase_ : int , lowercase_ : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = None SCREAMING_SNAKE_CASE_ : Optional[int] = None SCREAMING_SNAKE_CASE_ : Optional[int] = graph self._normalize_graph(lowercase_ , lowercase_) SCREAMING_SNAKE_CASE_ : Optional[Any] = len(lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = None def _SCREAMING_SNAKE_CASE ( self : Union[str, Any] , lowercase_ : Tuple , lowercase_ : str): '''simple docstring''' if sources is int: SCREAMING_SNAKE_CASE_ : str = [sources] if sinks is int: SCREAMING_SNAKE_CASE_ : Tuple = [sinks] if len(lowercase_) == 0 or len(lowercase_) == 0: return SCREAMING_SNAKE_CASE_ : int = sources[0] SCREAMING_SNAKE_CASE_ : Optional[Any] = sinks[0] # make fake vertex if there are more # than one source or sink if len(lowercase_) > 1 or len(lowercase_) > 1: SCREAMING_SNAKE_CASE_ : Dict = 0 for i in sources: max_input_flow += sum(self.graph[i]) SCREAMING_SNAKE_CASE_ : int = len(self.graph) + 1 for room in self.graph: room.insert(0 , 0) self.graph.insert(0 , [0] * size) for i in sources: SCREAMING_SNAKE_CASE_ : Union[str, Any] = max_input_flow SCREAMING_SNAKE_CASE_ : Optional[Any] = 0 SCREAMING_SNAKE_CASE_ : List[str] = len(self.graph) + 1 for room in self.graph: room.append(0) self.graph.append([0] * size) for i in sinks: SCREAMING_SNAKE_CASE_ : Union[str, Any] = max_input_flow SCREAMING_SNAKE_CASE_ : Tuple = size - 1 def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' if self.maximum_flow_algorithm is None: raise Exception('''You need to set maximum flow algorithm before.''') if self.source_index is None or self.sink_index is None: return 0 self.maximum_flow_algorithm.execute() return self.maximum_flow_algorithm.getMaximumFlow() def _SCREAMING_SNAKE_CASE ( self : Union[str, Any] , lowercase_ : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = algorithm(self) class lowerCAmelCase__ : '''simple docstring''' def __init__( self : Optional[Any] , lowercase_ : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = flow_network SCREAMING_SNAKE_CASE_ : Tuple = flow_network.verticesCount SCREAMING_SNAKE_CASE_ : Dict = flow_network.sourceIndex SCREAMING_SNAKE_CASE_ : Any = flow_network.sinkIndex # it's just a reference, so you shouldn't change # it in your algorithms, use deep copy before doing that SCREAMING_SNAKE_CASE_ : Dict = flow_network.graph SCREAMING_SNAKE_CASE_ : Union[str, Any] = False def _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' if not self.executed: self._algorithm() SCREAMING_SNAKE_CASE_ : Any = True def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' pass class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def __init__( self : Union[str, Any] , lowercase_ : int): '''simple docstring''' super().__init__(lowercase_) # use this to save your result SCREAMING_SNAKE_CASE_ : Dict = -1 def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' if not self.executed: raise Exception('''You should execute algorithm before using its result!''') return self.maximum_flow class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def __init__( self : int , lowercase_ : Optional[int]): '''simple docstring''' super().__init__(lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = [[0] * self.verticies_count for i in range(self.verticies_count)] SCREAMING_SNAKE_CASE_ : int = [0] * self.verticies_count SCREAMING_SNAKE_CASE_ : Union[str, Any] = [0] * self.verticies_count def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = self.verticies_count # push some substance to graph for nextvertex_index, bandwidth in enumerate(self.graph[self.source_index]): self.preflow[self.source_index][nextvertex_index] += bandwidth self.preflow[nextvertex_index][self.source_index] -= bandwidth self.excesses[nextvertex_index] += bandwidth # Relabel-to-front selection rule SCREAMING_SNAKE_CASE_ : Optional[int] = [ i for i in range(self.verticies_count) if i != self.source_index and i != self.sink_index ] # move through list SCREAMING_SNAKE_CASE_ : Union[str, Any] = 0 while i < len(lowercase_): SCREAMING_SNAKE_CASE_ : Union[str, Any] = vertices_list[i] SCREAMING_SNAKE_CASE_ : Tuple = self.heights[vertex_index] self.process_vertex(lowercase_) if self.heights[vertex_index] > previous_height: # if it was relabeled, swap elements # and start from 0 index vertices_list.insert(0 , vertices_list.pop(lowercase_)) SCREAMING_SNAKE_CASE_ : Union[str, Any] = 0 else: i += 1 SCREAMING_SNAKE_CASE_ : Union[str, Any] = sum(self.preflow[self.source_index]) def _SCREAMING_SNAKE_CASE ( self : int , lowercase_ : List[Any]): '''simple docstring''' while self.excesses[vertex_index] > 0: for neighbour_index in range(self.verticies_count): # if it's neighbour and current vertex is higher if ( self.graph[vertex_index][neighbour_index] - self.preflow[vertex_index][neighbour_index] > 0 and self.heights[vertex_index] > self.heights[neighbour_index] ): self.push(lowercase_ , lowercase_) self.relabel(lowercase_) def _SCREAMING_SNAKE_CASE ( self : Optional[int] , lowercase_ : Union[str, Any] , lowercase_ : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = min( self.excesses[from_index] , self.graph[from_index][to_index] - self.preflow[from_index][to_index] , ) self.preflow[from_index][to_index] += preflow_delta self.preflow[to_index][from_index] -= preflow_delta self.excesses[from_index] -= preflow_delta self.excesses[to_index] += preflow_delta def _SCREAMING_SNAKE_CASE ( self : List[Any] , lowercase_ : Tuple): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = None for to_index in range(self.verticies_count): if ( self.graph[vertex_index][to_index] - self.preflow[vertex_index][to_index] > 0 ) and (min_height is None or self.heights[to_index] < min_height): SCREAMING_SNAKE_CASE_ : Optional[Any] = self.heights[to_index] if min_height is not None: SCREAMING_SNAKE_CASE_ : List[Any] = min_height + 1 if __name__ == "__main__": UpperCAmelCase_ : Union[str, Any] = [0] UpperCAmelCase_ : str = [3] # graph = [ # [0, 0, 4, 6, 0, 0], # [0, 0, 5, 2, 0, 0], # [0, 0, 0, 0, 4, 4], # [0, 0, 0, 0, 6, 6], # [0, 0, 0, 0, 0, 0], # [0, 0, 0, 0, 0, 0], # ] UpperCAmelCase_ : List[str] = [[0, 7, 0, 0], [0, 0, 6, 0], [0, 0, 0, 8], [9, 0, 0, 0]] # prepare our network UpperCAmelCase_ : Optional[Any] = FlowNetwork(graph, entrances, exits) # set algorithm flow_network.set_maximum_flow_algorithm(PushRelabelExecutor) # and calculate UpperCAmelCase_ : Optional[Any] = flow_network.find_maximum_flow() print(f'''maximum flow is {maximum_flow}''')
367
"""simple docstring""" # tests directory-specific settings - this file is run automatically # by pytest before any tests are run import sys import warnings from os.path import abspath, dirname, join # allow having multiple repository checkouts and not needing to remember to rerun # 'pip install -e .[dev]' when switching between checkouts and running tests. UpperCAmelCase_ : Union[str, Any] = abspath(join(dirname(dirname(dirname(__file__))), """src""")) sys.path.insert(1, git_repo_path) # silence FutureWarning warnings in tests since often we can't act on them until # they become normal warnings - i.e. the tests still need to test the current functionality warnings.simplefilter(action="""ignore""", category=FutureWarning) def _A (__a ) -> Union[str, Any]: """simple docstring""" from transformers.testing_utils import pytest_addoption_shared pytest_addoption_shared(__a ) def _A (__a ) -> Any: """simple docstring""" from transformers.testing_utils import pytest_terminal_summary_main SCREAMING_SNAKE_CASE_ : Optional[Any] = terminalreporter.config.getoption('''--make-reports''' ) if make_reports: pytest_terminal_summary_main(__a , id=__a )
318
0
"""simple docstring""" import argparse import json import os import tensorstore as ts import torch from flax import serialization from flax.traverse_util import flatten_dict, unflatten_dict from tensorflow.io import gfile from transformers.modeling_utils import dtype_byte_size from transformers.models.switch_transformers.convert_switch_transformers_original_flax_checkpoint_to_pytorch import ( rename_keys, ) from transformers.utils import WEIGHTS_INDEX_NAME, WEIGHTS_NAME from transformers.utils.hub import convert_file_size_to_int def _A (__a , __a ) -> Any: """simple docstring""" if flax_key_tuple[-1] == "kernel" and flax_tensor.ndim == 3: # expert layer SCREAMING_SNAKE_CASE_ : int = flax_key_tuple[:-1] + ('''weight''',) SCREAMING_SNAKE_CASE_ : str = torch.permute(__a , (0, 2, 1) ) elif flax_key_tuple[-1] == "kernel" and ".".join(__a ): # linear layer SCREAMING_SNAKE_CASE_ : int = flax_key_tuple[:-1] + ('''weight''',) SCREAMING_SNAKE_CASE_ : List[str] = flax_tensor.T elif flax_key_tuple[-1] in ["scale", "embedding"]: SCREAMING_SNAKE_CASE_ : Union[str, Any] = flax_key_tuple[:-1] + ('''weight''',) return flax_key_tuple, flax_tensor def _A (__a , __a , __a ) -> Dict: """simple docstring""" if "metadata" in layer: SCREAMING_SNAKE_CASE_ : List[Any] = layer.split('''metadata''' ) SCREAMING_SNAKE_CASE_ : Tuple = ''''''.join(split_layer[0] )[:-1] SCREAMING_SNAKE_CASE_ : List[Any] = [tuple(('''metadata''' + split_layer[1]).split('''/''' ) )] elif "kvstore" in layer: SCREAMING_SNAKE_CASE_ : Optional[int] = layer.split('''kvstore''' ) SCREAMING_SNAKE_CASE_ : Optional[int] = ''''''.join(split_layer[0] )[:-1] SCREAMING_SNAKE_CASE_ : List[str] = [tuple(('''kvstore''' + split_layer[1]).split('''/''' ) )] else: SCREAMING_SNAKE_CASE_ : Union[str, Any] = layer.split('''/''' ) SCREAMING_SNAKE_CASE_ : Dict = '''/'''.join(split_layer[:-1] ) SCREAMING_SNAKE_CASE_ : List[str] = (split_layer[-1],) if "kvstore/path" in layer: SCREAMING_SNAKE_CASE_ : int = f'{switch_checkpoint_path}/{checkpoint_info[layer]}' elif "kvstore/driver" in layer: SCREAMING_SNAKE_CASE_ : str = '''file''' else: SCREAMING_SNAKE_CASE_ : str = checkpoint_info[layer] return curr_real_layer_name, split_layer, content def _A (__a , __a ) -> str: """simple docstring""" SCREAMING_SNAKE_CASE_ : Tuple = rename_keys(__a ) SCREAMING_SNAKE_CASE_ : str = {} for k, v in current_block.items(): SCREAMING_SNAKE_CASE_ : int = v SCREAMING_SNAKE_CASE_ : Tuple = new_current_block torch.save(__a , __a ) def _A (__a , __a , __a , __a , __a = WEIGHTS_NAME ) -> str: """simple docstring""" SCREAMING_SNAKE_CASE_ : str = convert_file_size_to_int(__a ) SCREAMING_SNAKE_CASE_ : List[str] = [] SCREAMING_SNAKE_CASE_ : List[Any] = {} SCREAMING_SNAKE_CASE_ : Any = 0 SCREAMING_SNAKE_CASE_ : Any = 0 os.makedirs(__a , exist_ok=__a ) with gfile.GFile(switch_checkpoint_path + '''/checkpoint''' , '''rb''' ) as fp: SCREAMING_SNAKE_CASE_ : List[str] = serialization.msgpack_restore(fp.read() )['''optimizer''']['''target'''] SCREAMING_SNAKE_CASE_ : Optional[int] = flatten_dict(__a , sep='''/''' ) SCREAMING_SNAKE_CASE_ : Optional[int] = {} for layer in checkpoint_info.keys(): SCREAMING_SNAKE_CASE_ : List[Any] = get_key_and_tensorstore_dict( __a , __a , __a ) if curr_real_layer_name in all_layers: SCREAMING_SNAKE_CASE_ : Dict = content else: SCREAMING_SNAKE_CASE_ : Tuple = {split_layer[-1]: content} for key in all_layers.keys(): # open tensorstore file SCREAMING_SNAKE_CASE_ : Union[str, Any] = ts.open(unflatten_dict(all_layers[key] ) ).result().read().result() SCREAMING_SNAKE_CASE_ : Optional[int] = torch.tensor(__a ) SCREAMING_SNAKE_CASE_ : Dict = raw_weights.numel() * dtype_byte_size(raw_weights.dtype ) # use the renaming pattern from the small conversion scripts SCREAMING_SNAKE_CASE_ : Dict = rename_base_flax_keys(tuple(key.split('''/''' ) ) , __a ) SCREAMING_SNAKE_CASE_ : List[Any] = '''/'''.join(__a ) # If this weight is going to tip up over the maximal size, we split. if current_block_size + weight_size > max_shard_size: SCREAMING_SNAKE_CASE_ : Dict = os.path.join( __a , weights_name.replace('''.bin''' , f'-{len(__a )+1:05d}-of-???.bin' ) ) rename_and_save_block(__a , __a ) sharded_state_dicts.append(current_block.keys() ) del current_block SCREAMING_SNAKE_CASE_ : Dict = {} SCREAMING_SNAKE_CASE_ : Any = 0 SCREAMING_SNAKE_CASE_ : Optional[int] = raw_weights.to(getattr(__a , __a ) ) current_block_size += weight_size total_size += weight_size # Add the last block SCREAMING_SNAKE_CASE_ : str = os.path.join(__a , weights_name.replace('''.bin''' , f'-{len(__a )+1:05d}-of-???.bin' ) ) rename_and_save_block(__a , __a ) sharded_state_dicts.append(current_block.keys() ) # If we only have one shard, we return it if len(__a ) == 1: return {weights_name: sharded_state_dicts[0]}, None # Otherwise, let's build the index SCREAMING_SNAKE_CASE_ : Tuple = {} SCREAMING_SNAKE_CASE_ : Tuple = {} for idx, shard in enumerate(__a ): SCREAMING_SNAKE_CASE_ : str = weights_name.replace( '''.bin''' , f'-{idx+1:05d}-of-{len(__a ):05d}.bin' ) # len(sharded_state_dicts):05d} SCREAMING_SNAKE_CASE_ : int = os.path.join(__a , weights_name.replace('''.bin''' , f'-{idx+1:05d}-of-???.bin' ) ) os.rename(__a , os.path.join(__a , __a ) ) SCREAMING_SNAKE_CASE_ : str = shard for key in shard: SCREAMING_SNAKE_CASE_ : Optional[Any] = shard_file # Add the metadata SCREAMING_SNAKE_CASE_ : Tuple = {'''total_size''': total_size} SCREAMING_SNAKE_CASE_ : Optional[Any] = {'''metadata''': metadata, '''weight_map''': weight_map} with open(os.path.join(__a , __a ) , '''w''' , encoding='''utf-8''' ) as f: SCREAMING_SNAKE_CASE_ : List[Any] = json.dumps(__a , indent=2 , sort_keys=__a ) + '''\n''' f.write(__a ) return metadata, index if __name__ == "__main__": UpperCAmelCase_ : Optional[int] = argparse.ArgumentParser() # Required parameters parser.add_argument( """--switch_t5x_checkpoint_path""", default="""/mnt/disks/disk_switch/original_checkpoints/switch-xxl-128/checkpoint_634600""", type=str, required=False, help="""Path to a directory containing a folder per layer. Follows the original Google format.""", ) parser.add_argument("""--max_shard_size""", default="""10GB""", required=False, help="""Max shard size""") parser.add_argument("""--dtype""", default="""bfloat16""", type=str, required=False, help="""dtype of the saved model""") parser.add_argument( """--pytorch_dump_folder_path""", default="""/mnt/disks/disk_switch/original_checkpoints/switch-xxl-128-converted""", type=str, required=False, help="""Path to the output pytorch model.""", ) UpperCAmelCase_ : List[Any] = parser.parse_args() shard_on_the_fly( args.switch_tax_checkpoint_path, args.pytorch_dump_folder_path, args.max_shard_size, args.dtype, ) def _A () -> Dict: """simple docstring""" from transformers import SwitchTransformersConfig, SwitchTransformersForConditionalGeneration, TaTokenizer SCREAMING_SNAKE_CASE_ : Tuple = SwitchTransformersConfig.from_pretrained('''google/switch-base-8''' ) config.save_pretrained('''/home/arthur_huggingface_co/transformers/switch_converted''' ) SCREAMING_SNAKE_CASE_ : List[str] = SwitchTransformersForConditionalGeneration.from_pretrained( '''/home/arthur_huggingface_co/transformers/switch_converted''' , device_map='''auto''' ) SCREAMING_SNAKE_CASE_ : Optional[int] = TaTokenizer.from_pretrained('''t5-small''' ) SCREAMING_SNAKE_CASE_ : Optional[Any] = '''A <extra_id_0> walks into a bar a orders a <extra_id_1> with <extra_id_2> pinch of <extra_id_3>.''' SCREAMING_SNAKE_CASE_ : Tuple = tokenizer(__a , return_tensors='''pt''' ).input_ids SCREAMING_SNAKE_CASE_ : Union[str, Any] = model.generate(__a , decoder_start_token_id=0 ) print(tokenizer.decode(out[0] ) )
368
"""simple docstring""" import argparse import os import re import packaging.version UpperCAmelCase_ : Any = """examples/""" UpperCAmelCase_ : Optional[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"""), } UpperCAmelCase_ : List[Any] = { """init""": """src/transformers/__init__.py""", """setup""": """setup.py""", } UpperCAmelCase_ : Optional[int] = """README.md""" def _A (__a , __a , __a ) -> int: """simple docstring""" with open(__a , '''r''' , encoding='''utf-8''' , newline='''\n''' ) as f: SCREAMING_SNAKE_CASE_ : Optional[Any] = f.read() SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : List[Any] = REPLACE_PATTERNS[pattern] SCREAMING_SNAKE_CASE_ : Optional[int] = replace.replace('''VERSION''' , __a ) SCREAMING_SNAKE_CASE_ : Tuple = re_pattern.sub(__a , __a ) with open(__a , '''w''' , encoding='''utf-8''' , newline='''\n''' ) as f: f.write(__a ) def _A (__a ) -> int: """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 _A (__a , __a=False ) -> List[str]: """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 _A () -> int: """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[Any] = '''🤗 Transformers currently provides the following architectures''' SCREAMING_SNAKE_CASE_ : Optional[int] = '''1. Want to contribute a new model?''' with open(__a , '''r''' , encoding='''utf-8''' , newline='''\n''' ) as f: SCREAMING_SNAKE_CASE_ : Tuple = f.readlines() # Find the start of the list. SCREAMING_SNAKE_CASE_ : Tuple = 0 while not lines[start_index].startswith(_start_prompt ): start_index += 1 start_index += 1 SCREAMING_SNAKE_CASE_ : Dict = start_index # Update the lines in the model list. while not lines[index].startswith(_end_prompt ): if lines[index].startswith('''1.''' ): SCREAMING_SNAKE_CASE_ : List[Any] = 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 _A () -> List[str]: """simple docstring""" with open(REPLACE_FILES['''init'''] , '''r''' ) as f: SCREAMING_SNAKE_CASE_ : Any = f.read() SCREAMING_SNAKE_CASE_ : Dict = REPLACE_PATTERNS['''init'''][0].search(__a ).groups()[0] return packaging.version.parse(__a ) def _A (__a=False ) -> List[Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Tuple = 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: SCREAMING_SNAKE_CASE_ : List[Any] = default_version.base_version elif patch: SCREAMING_SNAKE_CASE_ : int = f'{default_version.major}.{default_version.minor}.{default_version.micro + 1}' else: SCREAMING_SNAKE_CASE_ : Any = f'{default_version.major}.{default_version.minor + 1}.0' # Now let's ask nicely if that's the right one. SCREAMING_SNAKE_CASE_ : int = input(f'Which version are you releasing? [{default_version}]' ) if len(__a ) == 0: SCREAMING_SNAKE_CASE_ : Optional[Any] = 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 _A () -> Any: """simple docstring""" SCREAMING_SNAKE_CASE_ : Any = get_version() SCREAMING_SNAKE_CASE_ : Any = f'{current_version.major}.{current_version.minor + 1}.0.dev0' SCREAMING_SNAKE_CASE_ : Union[str, Any] = current_version.base_version # Check with the user we got that right. SCREAMING_SNAKE_CASE_ : int = input(f'Which version are we developing now? [{dev_version}]' ) if len(__a ) == 0: SCREAMING_SNAKE_CASE_ : Optional[int] = 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__": UpperCAmelCase_ : Optional[int] = argparse.ArgumentParser() parser.add_argument("""--post_release""", action="""store_true""", help="""Whether this is pre or post release.""") parser.add_argument("""--patch""", action="""store_true""", help="""Whether or not this is a patch release.""") UpperCAmelCase_ : 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()
318
0
"""simple docstring""" from packaging import version from .import_utils import is_accelerate_available if is_accelerate_available(): import accelerate def _A (__a ) -> Dict: """simple docstring""" if not is_accelerate_available(): return method SCREAMING_SNAKE_CASE_ : Any = version.parse(accelerate.__version__ ).base_version if version.parse(__a ) < version.parse('''0.17.0''' ): return method def wrapper(self , *__a , **__a ): if hasattr(self , '''_hf_hook''' ) and hasattr(self._hf_hook , '''pre_forward''' ): self._hf_hook.pre_forward(self ) return method(self , *__a , **__a ) return wrapper
369
"""simple docstring""" from typing import Optional, Tuple import jax import jax.numpy as jnp from flax import linen as nn from flax.core.frozen_dict import FrozenDict from transformers import CLIPConfig, FlaxPreTrainedModel from transformers.models.clip.modeling_flax_clip import FlaxCLIPVisionModule def _A (__a , __a , __a=1e-12 ) -> List[Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Union[str, Any] = jnp.divide(emb_a.T , jnp.clip(jnp.linalg.norm(__a , axis=1 ) , a_min=__a ) ).T SCREAMING_SNAKE_CASE_ : List[Any] = jnp.divide(emb_a.T , jnp.clip(jnp.linalg.norm(__a , axis=1 ) , a_min=__a ) ).T return jnp.matmul(__a , norm_emb_a.T ) class lowerCAmelCase__ ( nn.Module ): '''simple docstring''' __UpperCamelCase = 42 __UpperCamelCase = jnp.floataa def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = FlaxCLIPVisionModule(self.config.vision_config) SCREAMING_SNAKE_CASE_ : Tuple = nn.Dense(self.config.projection_dim , use_bias=lowercase_ , dtype=self.dtype) SCREAMING_SNAKE_CASE_ : List[str] = self.param('''concept_embeds''' , jax.nn.initializers.ones , (17, self.config.projection_dim)) SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.param( '''special_care_embeds''' , jax.nn.initializers.ones , (3, self.config.projection_dim)) SCREAMING_SNAKE_CASE_ : Dict = self.param('''concept_embeds_weights''' , jax.nn.initializers.ones , (17,)) SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.param('''special_care_embeds_weights''' , jax.nn.initializers.ones , (3,)) def __call__( self : Optional[Any] , lowercase_ : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = self.vision_model(lowercase_)[1] SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.visual_projection(lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = jax_cosine_distance(lowercase_ , self.special_care_embeds) SCREAMING_SNAKE_CASE_ : List[str] = jax_cosine_distance(lowercase_ , self.concept_embeds) # increase this value to create a stronger `nfsw` filter # at the cost of increasing the possibility of filtering benign image inputs SCREAMING_SNAKE_CASE_ : Tuple = 0.0 SCREAMING_SNAKE_CASE_ : Dict = special_cos_dist - self.special_care_embeds_weights[None, :] + adjustment SCREAMING_SNAKE_CASE_ : Optional[int] = jnp.round(lowercase_ , 3) SCREAMING_SNAKE_CASE_ : List[Any] = jnp.any(special_scores > 0 , axis=1 , keepdims=lowercase_) # Use a lower threshold if an image has any special care concept SCREAMING_SNAKE_CASE_ : Dict = is_special_care * 0.01 SCREAMING_SNAKE_CASE_ : str = cos_dist - self.concept_embeds_weights[None, :] + special_adjustment SCREAMING_SNAKE_CASE_ : Any = jnp.round(lowercase_ , 3) SCREAMING_SNAKE_CASE_ : Dict = jnp.any(concept_scores > 0 , axis=1) return has_nsfw_concepts class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = CLIPConfig __UpperCamelCase = "clip_input" __UpperCamelCase = FlaxStableDiffusionSafetyCheckerModule def __init__( self : Union[str, Any] , lowercase_ : CLIPConfig , lowercase_ : Optional[Tuple] = None , lowercase_ : int = 0 , lowercase_ : jnp.dtype = jnp.floataa , lowercase_ : bool = True , **lowercase_ : Any , ): '''simple docstring''' if input_shape is None: SCREAMING_SNAKE_CASE_ : List[str] = (1, 224, 224, 3) SCREAMING_SNAKE_CASE_ : List[Any] = self.module_class(config=lowercase_ , dtype=lowercase_ , **lowercase_) super().__init__(lowercase_ , lowercase_ , input_shape=lowercase_ , seed=lowercase_ , dtype=lowercase_ , _do_init=_do_init) def _SCREAMING_SNAKE_CASE ( self : Tuple , lowercase_ : jax.random.KeyArray , lowercase_ : Tuple , lowercase_ : FrozenDict = None): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = jax.random.normal(lowercase_ , lowercase_) SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Union[str, Any] = jax.random.split(lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = {'''params''': params_rng, '''dropout''': dropout_rng} SCREAMING_SNAKE_CASE_ : List[Any] = self.module.init(lowercase_ , lowercase_)['''params'''] return random_params def __call__( self : List[Any] , lowercase_ : List[str] , lowercase_ : dict = None , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = jnp.transpose(lowercase_ , (0, 2, 3, 1)) return self.module.apply( {'''params''': params or self.params} , jnp.array(lowercase_ , dtype=jnp.floataa) , rngs={} , )
318
0
from math import pow, sqrt def _A (*__a ) -> bool: """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[int] = len(__a ) > 0 and all(value > 0.0 for value in values ) return result def _A (__a , __a ) -> float | ValueError: """simple docstring""" return ( round(sqrt(molar_mass_a / molar_mass_a ) , 6 ) if validate(__a , __a ) else ValueError('''Input Error: Molar mass values must greater than 0.''' ) ) def _A (__a , __a , __a ) -> float | ValueError: """simple docstring""" return ( round(effusion_rate * sqrt(molar_mass_a / molar_mass_a ) , 6 ) if validate(__a , __a , __a ) else ValueError( '''Input Error: Molar mass and effusion rate values must greater than 0.''' ) ) def _A (__a , __a , __a ) -> float | ValueError: """simple docstring""" return ( round(effusion_rate / sqrt(molar_mass_a / molar_mass_a ) , 6 ) if validate(__a , __a , __a ) else ValueError( '''Input Error: Molar mass and effusion rate values must greater than 0.''' ) ) def _A (__a , __a , __a ) -> float | ValueError: """simple docstring""" return ( round(molar_mass / pow(effusion_rate_a / effusion_rate_a , 2 ) , 6 ) if validate(__a , __a , __a ) else ValueError( '''Input Error: Molar mass and effusion rate values must greater than 0.''' ) ) def _A (__a , __a , __a ) -> float | ValueError: """simple docstring""" return ( round(pow(effusion_rate_a / effusion_rate_a , 2 ) / molar_mass , 6 ) if validate(__a , __a , __a ) else ValueError( '''Input Error: Molar mass and effusion rate values must greater than 0.''' ) )
370
"""simple docstring""" from __future__ import annotations import queue class lowerCAmelCase__ : '''simple docstring''' def __init__( self : Tuple , lowercase_ : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = data SCREAMING_SNAKE_CASE_ : Tuple = None SCREAMING_SNAKE_CASE_ : Dict = None def _A () -> TreeNode: """simple docstring""" print('''\n********Press N to stop entering at any point of time********\n''' ) SCREAMING_SNAKE_CASE_ : List[Any] = input('''Enter the value of the root node: ''' ).strip().lower() SCREAMING_SNAKE_CASE_ : queue.Queue = queue.Queue() SCREAMING_SNAKE_CASE_ : Union[str, Any] = TreeNode(int(__a ) ) q.put(__a ) while not q.empty(): SCREAMING_SNAKE_CASE_ : Optional[int] = q.get() SCREAMING_SNAKE_CASE_ : List[str] = f'Enter the left node of {node_found.data}: ' SCREAMING_SNAKE_CASE_ : Optional[int] = input(__a ).strip().lower() or '''n''' if check == "n": return tree_node SCREAMING_SNAKE_CASE_ : List[str] = TreeNode(int(__a ) ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = left_node q.put(__a ) SCREAMING_SNAKE_CASE_ : str = f'Enter the right node of {node_found.data}: ' SCREAMING_SNAKE_CASE_ : str = input(__a ).strip().lower() or '''n''' if check == "n": return tree_node SCREAMING_SNAKE_CASE_ : Any = TreeNode(int(__a ) ) SCREAMING_SNAKE_CASE_ : int = right_node q.put(__a ) raise def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return print(node.data , end=''',''' ) pre_order(node.left ) pre_order(node.right ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return in_order(node.left ) print(node.data , end=''',''' ) in_order(node.right ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return post_order(node.left ) post_order(node.right ) print(node.data , end=''',''' ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ : queue.Queue = queue.Queue() q.put(__a ) while not q.empty(): SCREAMING_SNAKE_CASE_ : Tuple = q.get() print(node_dequeued.data , end=''',''' ) if node_dequeued.left: q.put(node_dequeued.left ) if node_dequeued.right: q.put(node_dequeued.right ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ : queue.Queue = queue.Queue() q.put(__a ) while not q.empty(): SCREAMING_SNAKE_CASE_ : str = [] while not q.empty(): SCREAMING_SNAKE_CASE_ : List[str] = q.get() print(node_dequeued.data , end=''',''' ) if node_dequeued.left: list_.append(node_dequeued.left ) if node_dequeued.right: list_.append(node_dequeued.right ) print() for node in list_: q.put(__a ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ : list[TreeNode] = [] SCREAMING_SNAKE_CASE_ : Union[str, Any] = node while n or stack: while n: # start from root node, find its left child print(n.data , end=''',''' ) stack.append(__a ) SCREAMING_SNAKE_CASE_ : Optional[Any] = n.left # end of while means current node doesn't have left child SCREAMING_SNAKE_CASE_ : Tuple = stack.pop() # start to traverse its right child SCREAMING_SNAKE_CASE_ : str = n.right def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ : list[TreeNode] = [] SCREAMING_SNAKE_CASE_ : Any = node while n or stack: while n: stack.append(__a ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = n.left SCREAMING_SNAKE_CASE_ : Any = stack.pop() print(n.data , end=''',''' ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = n.right def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Any = [], [] SCREAMING_SNAKE_CASE_ : List[Any] = node stacka.append(__a ) while stacka: # to find the reversed order of post order, store it in stack2 SCREAMING_SNAKE_CASE_ : List[str] = stacka.pop() if n.left: stacka.append(n.left ) if n.right: stacka.append(n.right ) stacka.append(__a ) while stacka: # pop up from stack2 will be the post order print(stacka.pop().data , end=''',''' ) def _A (__a = "" , __a=50 , __a="*" ) -> str: """simple docstring""" if not s: return "\n" + width * char SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Dict = divmod(width - len(__a ) - 2 , 2 ) return f'{left * char} {s} {(left + extra) * char}' if __name__ == "__main__": import doctest doctest.testmod() print(prompt("""Binary Tree Traversals""")) UpperCAmelCase_ : TreeNode = build_tree() print(prompt("""Pre Order Traversal""")) pre_order(node) print(prompt() + """\n""") print(prompt("""In Order Traversal""")) in_order(node) print(prompt() + """\n""") print(prompt("""Post Order Traversal""")) post_order(node) print(prompt() + """\n""") print(prompt("""Level Order Traversal""")) level_order(node) print(prompt() + """\n""") print(prompt("""Actual Level Order Traversal""")) level_order_actual(node) print("""*""" * 50 + """\n""") print(prompt("""Pre Order Traversal - Iteration Version""")) pre_order_iter(node) print(prompt() + """\n""") print(prompt("""In Order Traversal - Iteration Version""")) in_order_iter(node) print(prompt() + """\n""") print(prompt("""Post Order Traversal - Iteration Version""")) post_order_iter(node) print(prompt())
318
0
"""simple docstring""" import argparse import torch from transformers import BertConfig, BertForPreTraining, load_tf_weights_in_bert from transformers.utils import logging logging.set_verbosity_info() def _A (__a , __a , __a ) -> Optional[int]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Union[str, Any] = BertConfig.from_json_file(__a ) print(f'Building PyTorch model from configuration: {config}' ) SCREAMING_SNAKE_CASE_ : str = BertForPreTraining(__a ) # Load weights from tf checkpoint load_tf_weights_in_bert(__a , __a , __a ) # Save pytorch-model print(f'Save PyTorch model to {pytorch_dump_path}' ) torch.save(model.state_dict() , __a ) if __name__ == "__main__": UpperCAmelCase_ : int = argparse.ArgumentParser() # Required parameters parser.add_argument( """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path.""" ) parser.add_argument( """--bert_config_file""", default=None, type=str, required=True, help=( """The config json file corresponding to the pre-trained BERT model. \n""" """This specifies the model architecture.""" ), ) parser.add_argument( """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model.""" ) UpperCAmelCase_ : Union[str, Any] = parser.parse_args() convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)
371
"""simple docstring""" import random import unittest import numpy as np import torch from diffusers import ( DPMSolverMultistepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, LMSDiscreteScheduler, OnnxStableDiffusionUpscalePipeline, PNDMScheduler, ) from diffusers.utils import floats_tensor from diffusers.utils.testing_utils import ( is_onnx_available, load_image, nightly, require_onnxruntime, require_torch_gpu, ) from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin if is_onnx_available(): import onnxruntime as ort class lowerCAmelCase__ ( UpperCAmelCase__ , unittest.TestCase ): '''simple docstring''' __UpperCamelCase = "ssube/stable-diffusion-x4-upscaler-onnx" def _SCREAMING_SNAKE_CASE ( self : Optional[int] , lowercase_ : Union[str, Any]=0): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = floats_tensor((1, 3, 128, 128) , rng=random.Random(lowercase_)) SCREAMING_SNAKE_CASE_ : List[str] = torch.manual_seed(lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = { '''prompt''': '''A painting of a squirrel eating a burger''', '''image''': image, '''generator''': generator, '''num_inference_steps''': 3, '''guidance_scale''': 7.5, '''output_type''': '''numpy''', } return inputs def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''') pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : Tuple = self.get_dummy_inputs() SCREAMING_SNAKE_CASE_ : Union[str, Any] = pipe(**lowercase_).images SCREAMING_SNAKE_CASE_ : Dict = image[0, -3:, -3:, -1].flatten() # started as 128, should now be 512 assert image.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : Any = np.array( [0.6_97_47_82, 0.68_90_20_93, 0.70_13_58_85, 0.7_58_36_18, 0.7_80_45_45, 0.7_85_49_12, 0.78_66_74_26, 0.78_74_38_63, 0.78_07_02_23]) assert np.abs(image_slice - expected_slice).max() < 1e-1 def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''') SCREAMING_SNAKE_CASE_ : Optional[int] = PNDMScheduler.from_config(pipe.scheduler.config , skip_prk_steps=lowercase_) pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : Any = self.get_dummy_inputs() SCREAMING_SNAKE_CASE_ : Optional[Any] = pipe(**lowercase_).images SCREAMING_SNAKE_CASE_ : int = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : Any = np.array( [0.6_89_88_92, 0.59_24_05_56, 0.52_49_95_27, 0.58_86_62_15, 0.52_25_82_35, 0.52_57_27_15, 0.62_41_44_73, 0.6_17_43_87, 0.6_21_49_64]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-1 def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''') SCREAMING_SNAKE_CASE_ : Union[str, Any] = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = self.get_dummy_inputs() SCREAMING_SNAKE_CASE_ : Tuple = pipe(**lowercase_).images SCREAMING_SNAKE_CASE_ : Union[str, Any] = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : Tuple = np.array( [0.7_65_92_78, 0.76_43_76_64, 0.75_57_91_07, 0.7_69_11_16, 0.77_66_69_86, 0.7_72_76_72, 0.7_75_86_64, 0.7_81_22_26, 0.76_94_25_15]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-1 def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''') SCREAMING_SNAKE_CASE_ : List[Any] = EulerDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : Any = self.get_dummy_inputs() SCREAMING_SNAKE_CASE_ : Optional[Any] = pipe(**lowercase_).images SCREAMING_SNAKE_CASE_ : Optional[int] = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : Optional[Any] = np.array( [0.6_97_47_82, 0.68_90_20_93, 0.70_13_58_85, 0.7_58_36_18, 0.7_80_45_45, 0.7_85_49_12, 0.78_66_74_26, 0.78_74_38_63, 0.78_07_02_23]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-1 def _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''') SCREAMING_SNAKE_CASE_ : int = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = self.get_dummy_inputs() SCREAMING_SNAKE_CASE_ : Optional[int] = pipe(**lowercase_).images SCREAMING_SNAKE_CASE_ : str = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : int = np.array( [0.77_42_44_96, 0.77_36_01, 0.7_64_52_88, 0.7_76_95_98, 0.7_77_27_39, 0.7_73_86_88, 0.78_18_72_33, 0.77_87_95_84, 0.76_70_43]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-1 @nightly @require_onnxruntime @require_torch_gpu class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' @property def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' return ( "CUDAExecutionProvider", { "gpu_mem_limit": "15000000000", # 15GB "arena_extend_strategy": "kSameAsRequested", }, ) @property def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = ort.SessionOptions() SCREAMING_SNAKE_CASE_ : Optional[int] = False return options def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = load_image( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/img2img/sketch-mountains-input.jpg''') SCREAMING_SNAKE_CASE_ : Tuple = init_image.resize((128, 128)) # using the PNDM scheduler by default SCREAMING_SNAKE_CASE_ : List[str] = OnnxStableDiffusionUpscalePipeline.from_pretrained( '''ssube/stable-diffusion-x4-upscaler-onnx''' , provider=self.gpu_provider , sess_options=self.gpu_options , ) pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : Union[str, Any] = '''A fantasy landscape, trending on artstation''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = torch.manual_seed(0) SCREAMING_SNAKE_CASE_ : List[Any] = pipe( prompt=lowercase_ , image=lowercase_ , guidance_scale=7.5 , num_inference_steps=10 , generator=lowercase_ , output_type='''np''' , ) SCREAMING_SNAKE_CASE_ : Optional[int] = output.images SCREAMING_SNAKE_CASE_ : Optional[int] = images[0, 255:258, 383:386, -1] assert images.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : int = np.array([0.48_83, 0.49_47, 0.49_80, 0.49_75, 0.49_82, 0.49_80, 0.50_00, 0.50_06, 0.49_72]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2e-2 def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = load_image( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/img2img/sketch-mountains-input.jpg''') SCREAMING_SNAKE_CASE_ : Tuple = init_image.resize((128, 128)) SCREAMING_SNAKE_CASE_ : Tuple = LMSDiscreteScheduler.from_pretrained( '''ssube/stable-diffusion-x4-upscaler-onnx''' , subfolder='''scheduler''') SCREAMING_SNAKE_CASE_ : str = OnnxStableDiffusionUpscalePipeline.from_pretrained( '''ssube/stable-diffusion-x4-upscaler-onnx''' , scheduler=lowercase_ , provider=self.gpu_provider , sess_options=self.gpu_options , ) pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : int = '''A fantasy landscape, trending on artstation''' SCREAMING_SNAKE_CASE_ : List[Any] = torch.manual_seed(0) SCREAMING_SNAKE_CASE_ : int = pipe( prompt=lowercase_ , image=lowercase_ , guidance_scale=7.5 , num_inference_steps=20 , generator=lowercase_ , output_type='''np''' , ) SCREAMING_SNAKE_CASE_ : Optional[int] = output.images SCREAMING_SNAKE_CASE_ : Dict = images[0, 255:258, 383:386, -1] assert images.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : List[str] = np.array( [0.50_17_37_53, 0.50_22_33_56, 0.50_20_39, 0.50_23_30_36, 0.5_02_37_25, 0.5_02_26_01, 0.5_01_87_58, 0.50_23_40_85, 0.50_24_15_66]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2e-2
318
0
"""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 UpperCAmelCase_ : Union[str, Any] = logging.get_logger(__name__) UpperCAmelCase_ : Tuple = {"""vocab_file""": """spiece.model"""} UpperCAmelCase_ : Tuple = { """vocab_file""": { """TsinghuaAI/CPM-Generate""": """https://huggingface.co/TsinghuaAI/CPM-Generate/resolve/main/spiece.model""", } } class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def __init__( self : Optional[Any] , lowercase_ : Union[str, Any] , lowercase_ : List[str]=False , lowercase_ : int=True , lowercase_ : Union[str, Any]=False , lowercase_ : int="<s>" , lowercase_ : int="</s>" , lowercase_ : Optional[int]="<unk>" , lowercase_ : Any="<sep>" , lowercase_ : Union[str, Any]="<pad>" , lowercase_ : Tuple="<cls>" , lowercase_ : List[str]="<mask>" , lowercase_ : Optional[Any]=["<eop>", "<eod>"] , lowercase_ : Optional[Dict[str, Any]] = None , **lowercase_ : Union[str, Any] , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = AddedToken(lowercase_ , lstrip=lowercase_ , rstrip=lowercase_) if isinstance(lowercase_ , lowercase_) else mask_token SCREAMING_SNAKE_CASE_ : Dict = {} if sp_model_kwargs is None else sp_model_kwargs super().__init__( do_lower_case=lowercase_ , remove_space=lowercase_ , keep_accents=lowercase_ , bos_token=lowercase_ , eos_token=lowercase_ , unk_token=lowercase_ , sep_token=lowercase_ , pad_token=lowercase_ , cls_token=lowercase_ , mask_token=lowercase_ , additional_special_tokens=lowercase_ , sp_model_kwargs=self.sp_model_kwargs , **lowercase_ , ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = 3 SCREAMING_SNAKE_CASE_ : Any = do_lower_case SCREAMING_SNAKE_CASE_ : List[str] = remove_space SCREAMING_SNAKE_CASE_ : Any = keep_accents SCREAMING_SNAKE_CASE_ : str = vocab_file SCREAMING_SNAKE_CASE_ : Tuple = spm.SentencePieceProcessor(**self.sp_model_kwargs) self.sp_model.Load(lowercase_) 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.''') SCREAMING_SNAKE_CASE_ : List[Any] = jieba SCREAMING_SNAKE_CASE_ : List[Any] = str.maketrans(''' \n''' , '''\u2582\u2583''') @property # Copied from transformers.models.xlnet.tokenization_xlnet.XLNetTokenizer.vocab_size def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' return len(self.sp_model) def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = {self.convert_ids_to_tokens(lowercase_): i for i in range(self.vocab_size)} vocab.update(self.added_tokens_encoder) return vocab def __getstate__( self : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[str] = self.__dict__.copy() SCREAMING_SNAKE_CASE_ : Any = None return state def __setstate__( self : List[str] , lowercase_ : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = d # for backward compatibility if not hasattr(self , '''sp_model_kwargs'''): SCREAMING_SNAKE_CASE_ : Union[str, Any] = {} SCREAMING_SNAKE_CASE_ : Dict = spm.SentencePieceProcessor(**self.sp_model_kwargs) self.sp_model.Load(self.vocab_file) def _SCREAMING_SNAKE_CASE ( self : Optional[int] , lowercase_ : int): '''simple docstring''' if self.remove_space: SCREAMING_SNAKE_CASE_ : Union[str, Any] = ''' '''.join(inputs.strip().split()) else: SCREAMING_SNAKE_CASE_ : str = inputs SCREAMING_SNAKE_CASE_ : Tuple = outputs.replace('''``''' , '''"''').replace('''\'\'''' , '''"''') if not self.keep_accents: SCREAMING_SNAKE_CASE_ : int = unicodedata.normalize('''NFKD''' , lowercase_) SCREAMING_SNAKE_CASE_ : str = ''''''.join([c for c in outputs if not unicodedata.combining(lowercase_)]) if self.do_lower_case: SCREAMING_SNAKE_CASE_ : str = outputs.lower() return outputs def _SCREAMING_SNAKE_CASE ( self : Any , lowercase_ : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = self.preprocess_text(lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = self.sp_model.encode(lowercase_ , out_type=lowercase_) SCREAMING_SNAKE_CASE_ : int = [] for piece in pieces: if len(lowercase_) > 1 and piece[-1] == str(''',''') and piece[-2].isdigit(): SCREAMING_SNAKE_CASE_ : List[Any] = self.sp_model.EncodeAsPieces(piece[:-1].replace(lowercase_ , '''''')) if piece[0] != SPIECE_UNDERLINE and cur_pieces[0][0] == SPIECE_UNDERLINE: if len(cur_pieces[0]) == 1: SCREAMING_SNAKE_CASE_ : Dict = cur_pieces[1:] else: SCREAMING_SNAKE_CASE_ : Union[str, Any] = cur_pieces[0][1:] cur_pieces.append(piece[-1]) new_pieces.extend(lowercase_) else: new_pieces.append(lowercase_) return new_pieces def _SCREAMING_SNAKE_CASE ( self : Optional[int] , lowercase_ : List[str]): '''simple docstring''' return self.sp_model.PieceToId(lowercase_) def _SCREAMING_SNAKE_CASE ( self : int , lowercase_ : Any): '''simple docstring''' return self.sp_model.IdToPiece(lowercase_) def _SCREAMING_SNAKE_CASE ( self : Optional[Any] , lowercase_ : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = ''''''.join(lowercase_).replace(lowercase_ , ''' ''').strip() return out_string def _SCREAMING_SNAKE_CASE ( self : Any , lowercase_ : List[int] , lowercase_ : Optional[List[int]] = None): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = [self.sep_token_id] SCREAMING_SNAKE_CASE_ : Tuple = [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 _SCREAMING_SNAKE_CASE ( self : Optional[Any] , lowercase_ : List[int] , lowercase_ : Optional[List[int]] = None , lowercase_ : bool = False): '''simple docstring''' if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=lowercase_ , token_ids_a=lowercase_ , already_has_special_tokens=lowercase_) if token_ids_a is not None: return ([0] * len(lowercase_)) + [1] + ([0] * len(lowercase_)) + [1, 1] return ([0] * len(lowercase_)) + [1, 1] def _SCREAMING_SNAKE_CASE ( self : str , lowercase_ : List[int] , lowercase_ : Optional[List[int]] = None): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = [self.sep_token_id] SCREAMING_SNAKE_CASE_ : str = [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 _SCREAMING_SNAKE_CASE ( self : Union[str, Any] , lowercase_ : str , lowercase_ : Optional[str] = None): '''simple docstring''' if not os.path.isdir(lowercase_): logger.error(F'Vocabulary path ({save_directory}) should be a directory') return SCREAMING_SNAKE_CASE_ : int = os.path.join( lowercase_ , (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']) if os.path.abspath(self.vocab_file) != os.path.abspath(lowercase_) and os.path.isfile(self.vocab_file): copyfile(self.vocab_file , lowercase_) elif not os.path.isfile(self.vocab_file): with open(lowercase_ , '''wb''') as fi: SCREAMING_SNAKE_CASE_ : Tuple = self.sp_model.serialized_model_proto() fi.write(lowercase_) return (out_vocab_file,) def _SCREAMING_SNAKE_CASE ( self : List[Any] , *lowercase_ : Dict , **lowercase_ : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = super()._decode(*lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : Union[str, Any] = text.replace(''' ''' , '''''').replace('''\u2582''' , ''' ''').replace('''\u2583''' , '''\n''') return text
350
"""simple docstring""" from scipy.stats import pearsonr import datasets UpperCAmelCase_ : List[Any] = """ Pearson correlation coefficient and p-value for testing non-correlation. The Pearson correlation coefficient measures the linear relationship between two datasets. The calculation of the p-value relies on the assumption that each dataset is normally distributed. Like other correlation coefficients, this one varies between -1 and +1 with 0 implying no correlation. Correlations of -1 or +1 imply an exact linear relationship. Positive correlations imply that as x increases, so does y. Negative correlations imply that as x increases, y decreases. The p-value roughly indicates the probability of an uncorrelated system producing datasets that have a Pearson correlation at least as extreme as the one computed from these datasets. """ UpperCAmelCase_ : Optional[int] = """ Args: predictions (`list` of `int`): Predicted class labels, as returned by a model. references (`list` of `int`): Ground truth labels. return_pvalue (`boolean`): If `True`, returns the p-value, along with the correlation coefficient. If `False`, returns only the correlation coefficient. Defaults to `False`. Returns: pearsonr (`float`): Pearson correlation coefficient. Minimum possible value is -1. Maximum possible value is 1. Values of 1 and -1 indicate exact linear positive and negative relationships, respectively. A value of 0 implies no correlation. p-value (`float`): P-value, which roughly indicates the probability of an The p-value roughly indicates the probability of an uncorrelated system producing datasets that have a Pearson correlation at least as extreme as the one computed from these datasets. Minimum possible value is 0. Maximum possible value is 1. Higher values indicate higher probabilities. Examples: Example 1-A simple example using only predictions and references. >>> pearsonr_metric = datasets.load_metric(\"pearsonr\") >>> results = pearsonr_metric.compute(predictions=[10, 9, 2.5, 6, 4], references=[1, 2, 3, 4, 5]) >>> print(round(results['pearsonr'], 2)) -0.74 Example 2-The same as Example 1, but that also returns the `p-value`. >>> pearsonr_metric = datasets.load_metric(\"pearsonr\") >>> results = pearsonr_metric.compute(predictions=[10, 9, 2.5, 6, 4], references=[1, 2, 3, 4, 5], return_pvalue=True) >>> print(sorted(list(results.keys()))) ['p-value', 'pearsonr'] >>> print(round(results['pearsonr'], 2)) -0.74 >>> print(round(results['p-value'], 2)) 0.15 """ UpperCAmelCase_ : Tuple = """ @article{2020SciPy-NMeth, author = {Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E. and Haberland, Matt and Reddy, Tyler and Cournapeau, David and Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and Bright, Jonathan and {van der Walt}, St{\'e}fan J. and Brett, Matthew and Wilson, Joshua and Millman, K. Jarrod and Mayorov, Nikolay and Nelson, Andrew R. J. and Jones, Eric and Kern, Robert and Larson, Eric and Carey, C J and Polat, Ilhan and Feng, Yu and Moore, Eric W. and {VanderPlas}, Jake and Laxalde, Denis and Perktold, Josef and Cimrman, Robert and Henriksen, Ian and Quintero, E. A. and Harris, Charles R. and Archibald, Anne M. and Ribeiro, Antonio H. and Pedregosa, Fabian and {van Mulbregt}, Paul and {SciPy 1.0 Contributors}}, title = {{{SciPy} 1.0: Fundamental Algorithms for Scientific Computing in Python}}, journal = {Nature Methods}, year = {2020}, volume = {17}, pages = {261--272}, adsurl = {https://rdcu.be/b08Wh}, doi = {10.1038/s41592-019-0686-2}, } """ @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class lowerCAmelCase__ ( datasets.Metric ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { '''predictions''': datasets.Value('''float'''), '''references''': datasets.Value('''float'''), }) , reference_urls=['''https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.pearsonr.html'''] , ) def _SCREAMING_SNAKE_CASE ( self : List[Any] , lowercase_ : List[str] , lowercase_ : List[Any] , lowercase_ : Union[str, Any]=False): '''simple docstring''' if return_pvalue: SCREAMING_SNAKE_CASE_ : int = pearsonr(lowercase_ , lowercase_) return {"pearsonr": results[0], "p-value": results[1]} else: return {"pearsonr": float(pearsonr(lowercase_ , lowercase_)[0])}
318
0
"""simple docstring""" from typing import Optional, Tuple import jax import jax.numpy as jnp from flax import linen as nn from flax.core.frozen_dict import FrozenDict from transformers import CLIPConfig, FlaxPreTrainedModel from transformers.models.clip.modeling_flax_clip import FlaxCLIPVisionModule def _A (__a , __a , __a=1e-12 ) -> List[Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Union[str, Any] = jnp.divide(emb_a.T , jnp.clip(jnp.linalg.norm(__a , axis=1 ) , a_min=__a ) ).T SCREAMING_SNAKE_CASE_ : List[Any] = jnp.divide(emb_a.T , jnp.clip(jnp.linalg.norm(__a , axis=1 ) , a_min=__a ) ).T return jnp.matmul(__a , norm_emb_a.T ) class lowerCAmelCase__ ( nn.Module ): '''simple docstring''' __UpperCamelCase = 4_2 __UpperCamelCase = jnp.floataa def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = FlaxCLIPVisionModule(self.config.vision_config) SCREAMING_SNAKE_CASE_ : Tuple = nn.Dense(self.config.projection_dim , use_bias=lowercase_ , dtype=self.dtype) SCREAMING_SNAKE_CASE_ : List[str] = self.param('''concept_embeds''' , jax.nn.initializers.ones , (17, self.config.projection_dim)) SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.param( '''special_care_embeds''' , jax.nn.initializers.ones , (3, self.config.projection_dim)) SCREAMING_SNAKE_CASE_ : Dict = self.param('''concept_embeds_weights''' , jax.nn.initializers.ones , (17,)) SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.param('''special_care_embeds_weights''' , jax.nn.initializers.ones , (3,)) def __call__( self : Optional[Any] , lowercase_ : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = self.vision_model(lowercase_)[1] SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.visual_projection(lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = jax_cosine_distance(lowercase_ , self.special_care_embeds) SCREAMING_SNAKE_CASE_ : List[str] = jax_cosine_distance(lowercase_ , self.concept_embeds) # increase this value to create a stronger `nfsw` filter # at the cost of increasing the possibility of filtering benign image inputs SCREAMING_SNAKE_CASE_ : Tuple = 0.0 SCREAMING_SNAKE_CASE_ : Dict = special_cos_dist - self.special_care_embeds_weights[None, :] + adjustment SCREAMING_SNAKE_CASE_ : Optional[int] = jnp.round(lowercase_ , 3) SCREAMING_SNAKE_CASE_ : List[Any] = jnp.any(special_scores > 0 , axis=1 , keepdims=lowercase_) # Use a lower threshold if an image has any special care concept SCREAMING_SNAKE_CASE_ : Dict = is_special_care * 0.01 SCREAMING_SNAKE_CASE_ : str = cos_dist - self.concept_embeds_weights[None, :] + special_adjustment SCREAMING_SNAKE_CASE_ : Any = jnp.round(lowercase_ , 3) SCREAMING_SNAKE_CASE_ : Dict = jnp.any(concept_scores > 0 , axis=1) return has_nsfw_concepts class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = CLIPConfig __UpperCamelCase = "clip_input" __UpperCamelCase = FlaxStableDiffusionSafetyCheckerModule def __init__( self : Union[str, Any] , lowercase_ : CLIPConfig , lowercase_ : Optional[Tuple] = None , lowercase_ : int = 0 , lowercase_ : jnp.dtype = jnp.floataa , lowercase_ : bool = True , **lowercase_ : Any , ): '''simple docstring''' if input_shape is None: SCREAMING_SNAKE_CASE_ : List[str] = (1, 224, 224, 3) SCREAMING_SNAKE_CASE_ : List[Any] = self.module_class(config=lowercase_ , dtype=lowercase_ , **lowercase_) super().__init__(lowercase_ , lowercase_ , input_shape=lowercase_ , seed=lowercase_ , dtype=lowercase_ , _do_init=_do_init) def _SCREAMING_SNAKE_CASE ( self : Tuple , lowercase_ : jax.random.KeyArray , lowercase_ : Tuple , lowercase_ : FrozenDict = None): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = jax.random.normal(lowercase_ , lowercase_) SCREAMING_SNAKE_CASE_ : Union[str, Any] = jax.random.split(lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = {'''params''': params_rng, '''dropout''': dropout_rng} SCREAMING_SNAKE_CASE_ : List[Any] = self.module.init(lowercase_ , lowercase_)['''params'''] return random_params def __call__( self : List[Any] , lowercase_ : List[str] , lowercase_ : dict = None , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = jnp.transpose(lowercase_ , (0, 2, 3, 1)) return self.module.apply( {'''params''': params or self.params} , jnp.array(lowercase_ , dtype=jnp.floataa) , rngs={} , )
351
"""simple docstring""" import os from typing import Dict, List, Union import tensorflow as tf from keras_nlp.tokenizers import BytePairTokenizer from tensorflow_text import pad_model_inputs from .tokenization_gpta import GPTaTokenizer class lowerCAmelCase__ ( tf.keras.layers.Layer ): '''simple docstring''' def __init__( self : Any , lowercase_ : Dict[str, int] , lowercase_ : List[str] , lowercase_ : int = None , lowercase_ : int = None): '''simple docstring''' super().__init__() SCREAMING_SNAKE_CASE_ : str = pad_token_id SCREAMING_SNAKE_CASE_ : Optional[int] = max_length SCREAMING_SNAKE_CASE_ : Dict = vocab SCREAMING_SNAKE_CASE_ : Dict = merges SCREAMING_SNAKE_CASE_ : Union[str, Any] = BytePairTokenizer(lowercase_ , lowercase_ , sequence_length=lowercase_) @classmethod def _SCREAMING_SNAKE_CASE ( cls : Dict , lowercase_ : GPTaTokenizer , *lowercase_ : Optional[Any] , **lowercase_ : Tuple): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = [''' '''.join(lowercase_) for m in tokenizer.bpe_ranks.keys()] SCREAMING_SNAKE_CASE_ : str = tokenizer.get_vocab() return cls(lowercase_ , lowercase_ , *lowercase_ , **lowercase_) @classmethod def _SCREAMING_SNAKE_CASE ( cls : int , lowercase_ : Union[str, os.PathLike] , *lowercase_ : List[str] , **lowercase_ : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = GPTaTokenizer.from_pretrained(lowercase_ , *lowercase_ , **lowercase_) return cls.from_tokenizer(lowercase_ , *lowercase_ , **lowercase_) @classmethod def _SCREAMING_SNAKE_CASE ( cls : Dict , lowercase_ : List[Any]): '''simple docstring''' return cls(**lowercase_) def _SCREAMING_SNAKE_CASE ( self : Tuple): '''simple docstring''' return { "vocab": self.vocab, "merges": self.merges, "max_length": self.max_length, "pad_token_id": self.pad_token_id, } def _SCREAMING_SNAKE_CASE ( self : Any , lowercase_ : List[Any] , lowercase_ : int = None): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = self.tf_tokenizer(lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = tf.ones_like(lowercase_) if self.pad_token_id is not None: # pad the tokens up to max length SCREAMING_SNAKE_CASE_ : Union[str, Any] = max_length if max_length is not None else self.max_length if max_length is not None: SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : List[str] = pad_model_inputs( lowercase_ , max_seq_length=lowercase_ , pad_value=self.pad_token_id) return {"attention_mask": attention_mask, "input_ids": input_ids}
318
0
"""simple docstring""" from itertools import permutations def _A (__a ) -> bool: """simple docstring""" if num[3] % 2 != 0: return False if (num[2] + num[3] + num[4]) % 3 != 0: return False if num[5] % 5 != 0: return False SCREAMING_SNAKE_CASE_ : List[str] = [7, 11, 13, 17] for i, test in enumerate(__a ): if (num[i + 4] * 1_00 + num[i + 5] * 10 + num[i + 6]) % test != 0: return False return True def _A (__a = 10 ) -> int: """simple docstring""" return sum( int(''''''.join(map(__a , __a ) ) ) for num in permutations(range(__a ) ) if is_substring_divisible(__a ) ) if __name__ == "__main__": print(f'''{solution() = }''')
352
"""simple docstring""" import json import os import shutil import tempfile import unittest import numpy as np import pytest from transformers import BertTokenizer, BertTokenizerFast from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES from transformers.testing_utils import require_vision from transformers.utils import FEATURE_EXTRACTOR_NAME, is_vision_available if is_vision_available(): from PIL import Image from transformers import ChineseCLIPImageProcessor, ChineseCLIPProcessor @require_vision class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = tempfile.mkdtemp() SCREAMING_SNAKE_CASE_ : Union[str, Any] = [ '''[UNK]''', '''[CLS]''', '''[SEP]''', '''[PAD]''', '''[MASK]''', '''的''', '''价''', '''格''', '''是''', '''15''', '''便''', '''alex''', '''##andra''', ''',''', '''。''', '''-''', '''t''', '''shirt''', ] SCREAMING_SNAKE_CASE_ : int = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['''vocab_file''']) with open(self.vocab_file , '''w''' , encoding='''utf-8''') as vocab_writer: vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens])) SCREAMING_SNAKE_CASE_ : Dict = { '''do_resize''': True, '''size''': {'''height''': 224, '''width''': 224}, '''do_center_crop''': True, '''crop_size''': {'''height''': 18, '''width''': 18}, '''do_normalize''': True, '''image_mean''': [0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73], '''image_std''': [0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11], '''do_convert_rgb''': True, } SCREAMING_SNAKE_CASE_ : int = os.path.join(self.tmpdirname , lowercase_) with open(self.image_processor_file , '''w''' , encoding='''utf-8''') as fp: json.dump(lowercase_ , lowercase_) def _SCREAMING_SNAKE_CASE ( self : Optional[int] , **lowercase_ : str): '''simple docstring''' return BertTokenizer.from_pretrained(self.tmpdirname , **lowercase_) def _SCREAMING_SNAKE_CASE ( self : Tuple , **lowercase_ : List[Any]): '''simple docstring''' return BertTokenizerFast.from_pretrained(self.tmpdirname , **lowercase_) def _SCREAMING_SNAKE_CASE ( self : List[Any] , **lowercase_ : str): '''simple docstring''' return ChineseCLIPImageProcessor.from_pretrained(self.tmpdirname , **lowercase_) def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' shutil.rmtree(self.tmpdirname) def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = [np.random.randint(255 , size=(3, 30, 400) , dtype=np.uinta)] SCREAMING_SNAKE_CASE_ : Dict = [Image.fromarray(np.moveaxis(lowercase_ , 0 , -1)) for x in image_inputs] return image_inputs def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.get_rust_tokenizer() SCREAMING_SNAKE_CASE_ : Any = self.get_image_processor() SCREAMING_SNAKE_CASE_ : int = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) processor_slow.save_pretrained(self.tmpdirname) SCREAMING_SNAKE_CASE_ : Optional[int] = ChineseCLIPProcessor.from_pretrained(self.tmpdirname , use_fast=lowercase_) SCREAMING_SNAKE_CASE_ : Any = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) processor_fast.save_pretrained(self.tmpdirname) SCREAMING_SNAKE_CASE_ : int = ChineseCLIPProcessor.from_pretrained(self.tmpdirname) self.assertEqual(processor_slow.tokenizer.get_vocab() , tokenizer_slow.get_vocab()) self.assertEqual(processor_fast.tokenizer.get_vocab() , tokenizer_fast.get_vocab()) self.assertEqual(tokenizer_slow.get_vocab() , tokenizer_fast.get_vocab()) self.assertIsInstance(processor_slow.tokenizer , lowercase_) self.assertIsInstance(processor_fast.tokenizer , lowercase_) self.assertEqual(processor_slow.image_processor.to_json_string() , image_processor.to_json_string()) self.assertEqual(processor_fast.image_processor.to_json_string() , image_processor.to_json_string()) self.assertIsInstance(processor_slow.image_processor , lowercase_) self.assertIsInstance(processor_fast.image_processor , lowercase_) def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = ChineseCLIPProcessor(tokenizer=self.get_tokenizer() , image_processor=self.get_image_processor()) processor.save_pretrained(self.tmpdirname) SCREAMING_SNAKE_CASE_ : Optional[int] = self.get_tokenizer(cls_token='''(CLS)''' , sep_token='''(SEP)''') SCREAMING_SNAKE_CASE_ : Optional[int] = self.get_image_processor(do_normalize=lowercase_) SCREAMING_SNAKE_CASE_ : Tuple = ChineseCLIPProcessor.from_pretrained( self.tmpdirname , cls_token='''(CLS)''' , sep_token='''(SEP)''' , do_normalize=lowercase_) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab()) self.assertIsInstance(processor.tokenizer , lowercase_) self.assertEqual(processor.image_processor.to_json_string() , image_processor_add_kwargs.to_json_string()) self.assertIsInstance(processor.image_processor , lowercase_) def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = self.get_image_processor() SCREAMING_SNAKE_CASE_ : List[Any] = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : Tuple = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = self.prepare_image_inputs() SCREAMING_SNAKE_CASE_ : Any = image_processor(lowercase_ , return_tensors='''np''') SCREAMING_SNAKE_CASE_ : Union[str, Any] = processor(images=lowercase_ , return_tensors='''np''') for key in input_feat_extract.keys(): self.assertAlmostEqual(input_feat_extract[key].sum() , input_processor[key].sum() , delta=1e-2) def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = self.get_image_processor() SCREAMING_SNAKE_CASE_ : Any = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : str = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) SCREAMING_SNAKE_CASE_ : Dict = '''Alexandra,T-shirt的价格是15便士。''' SCREAMING_SNAKE_CASE_ : Optional[Any] = processor(text=lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = tokenizer(lowercase_) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key]) def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = self.get_image_processor() SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : int = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) SCREAMING_SNAKE_CASE_ : Union[str, Any] = '''Alexandra,T-shirt的价格是15便士。''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.prepare_image_inputs() SCREAMING_SNAKE_CASE_ : int = processor(text=lowercase_ , images=lowercase_) self.assertListEqual(list(inputs.keys()) , ['''input_ids''', '''token_type_ids''', '''attention_mask''', '''pixel_values''']) # test if it raises when no input is passed with pytest.raises(lowercase_): processor() def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.get_image_processor() SCREAMING_SNAKE_CASE_ : List[Any] = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : Optional[int] = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) SCREAMING_SNAKE_CASE_ : Any = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] SCREAMING_SNAKE_CASE_ : Optional[int] = processor.batch_decode(lowercase_) SCREAMING_SNAKE_CASE_ : Dict = tokenizer.batch_decode(lowercase_) self.assertListEqual(lowercase_ , lowercase_) def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = self.get_image_processor() SCREAMING_SNAKE_CASE_ : Dict = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : Dict = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = '''Alexandra,T-shirt的价格是15便士。''' SCREAMING_SNAKE_CASE_ : Dict = self.prepare_image_inputs() SCREAMING_SNAKE_CASE_ : Dict = processor(text=lowercase_ , images=lowercase_) self.assertListEqual(list(inputs.keys()) , processor.model_input_names)
318
0
"""simple docstring""" from ..models.auto import AutoModelForSeqaSeqLM, AutoTokenizer from .base import PipelineTool UpperCAmelCase_ : int = { """Acehnese Arabic""": """ace_Arab""", """Acehnese Latin""": """ace_Latn""", """Mesopotamian Arabic""": """acm_Arab""", """Ta'izzi-Adeni Arabic""": """acq_Arab""", """Tunisian Arabic""": """aeb_Arab""", """Afrikaans""": """afr_Latn""", """South Levantine Arabic""": """ajp_Arab""", """Akan""": """aka_Latn""", """Amharic""": """amh_Ethi""", """North Levantine Arabic""": """apc_Arab""", """Modern Standard Arabic""": """arb_Arab""", """Modern Standard Arabic Romanized""": """arb_Latn""", """Najdi Arabic""": """ars_Arab""", """Moroccan Arabic""": """ary_Arab""", """Egyptian Arabic""": """arz_Arab""", """Assamese""": """asm_Beng""", """Asturian""": """ast_Latn""", """Awadhi""": """awa_Deva""", """Central Aymara""": """ayr_Latn""", """South Azerbaijani""": """azb_Arab""", """North Azerbaijani""": """azj_Latn""", """Bashkir""": """bak_Cyrl""", """Bambara""": """bam_Latn""", """Balinese""": """ban_Latn""", """Belarusian""": """bel_Cyrl""", """Bemba""": """bem_Latn""", """Bengali""": """ben_Beng""", """Bhojpuri""": """bho_Deva""", """Banjar Arabic""": """bjn_Arab""", """Banjar Latin""": """bjn_Latn""", """Standard Tibetan""": """bod_Tibt""", """Bosnian""": """bos_Latn""", """Buginese""": """bug_Latn""", """Bulgarian""": """bul_Cyrl""", """Catalan""": """cat_Latn""", """Cebuano""": """ceb_Latn""", """Czech""": """ces_Latn""", """Chokwe""": """cjk_Latn""", """Central Kurdish""": """ckb_Arab""", """Crimean Tatar""": """crh_Latn""", """Welsh""": """cym_Latn""", """Danish""": """dan_Latn""", """German""": """deu_Latn""", """Southwestern Dinka""": """dik_Latn""", """Dyula""": """dyu_Latn""", """Dzongkha""": """dzo_Tibt""", """Greek""": """ell_Grek""", """English""": """eng_Latn""", """Esperanto""": """epo_Latn""", """Estonian""": """est_Latn""", """Basque""": """eus_Latn""", """Ewe""": """ewe_Latn""", """Faroese""": """fao_Latn""", """Fijian""": """fij_Latn""", """Finnish""": """fin_Latn""", """Fon""": """fon_Latn""", """French""": """fra_Latn""", """Friulian""": """fur_Latn""", """Nigerian Fulfulde""": """fuv_Latn""", """Scottish Gaelic""": """gla_Latn""", """Irish""": """gle_Latn""", """Galician""": """glg_Latn""", """Guarani""": """grn_Latn""", """Gujarati""": """guj_Gujr""", """Haitian Creole""": """hat_Latn""", """Hausa""": """hau_Latn""", """Hebrew""": """heb_Hebr""", """Hindi""": """hin_Deva""", """Chhattisgarhi""": """hne_Deva""", """Croatian""": """hrv_Latn""", """Hungarian""": """hun_Latn""", """Armenian""": """hye_Armn""", """Igbo""": """ibo_Latn""", """Ilocano""": """ilo_Latn""", """Indonesian""": """ind_Latn""", """Icelandic""": """isl_Latn""", """Italian""": """ita_Latn""", """Javanese""": """jav_Latn""", """Japanese""": """jpn_Jpan""", """Kabyle""": """kab_Latn""", """Jingpho""": """kac_Latn""", """Kamba""": """kam_Latn""", """Kannada""": """kan_Knda""", """Kashmiri Arabic""": """kas_Arab""", """Kashmiri Devanagari""": """kas_Deva""", """Georgian""": """kat_Geor""", """Central Kanuri Arabic""": """knc_Arab""", """Central Kanuri Latin""": """knc_Latn""", """Kazakh""": """kaz_Cyrl""", """Kabiyè""": """kbp_Latn""", """Kabuverdianu""": """kea_Latn""", """Khmer""": """khm_Khmr""", """Kikuyu""": """kik_Latn""", """Kinyarwanda""": """kin_Latn""", """Kyrgyz""": """kir_Cyrl""", """Kimbundu""": """kmb_Latn""", """Northern Kurdish""": """kmr_Latn""", """Kikongo""": """kon_Latn""", """Korean""": """kor_Hang""", """Lao""": """lao_Laoo""", """Ligurian""": """lij_Latn""", """Limburgish""": """lim_Latn""", """Lingala""": """lin_Latn""", """Lithuanian""": """lit_Latn""", """Lombard""": """lmo_Latn""", """Latgalian""": """ltg_Latn""", """Luxembourgish""": """ltz_Latn""", """Luba-Kasai""": """lua_Latn""", """Ganda""": """lug_Latn""", """Luo""": """luo_Latn""", """Mizo""": """lus_Latn""", """Standard Latvian""": """lvs_Latn""", """Magahi""": """mag_Deva""", """Maithili""": """mai_Deva""", """Malayalam""": """mal_Mlym""", """Marathi""": """mar_Deva""", """Minangkabau Arabic """: """min_Arab""", """Minangkabau Latin""": """min_Latn""", """Macedonian""": """mkd_Cyrl""", """Plateau Malagasy""": """plt_Latn""", """Maltese""": """mlt_Latn""", """Meitei Bengali""": """mni_Beng""", """Halh Mongolian""": """khk_Cyrl""", """Mossi""": """mos_Latn""", """Maori""": """mri_Latn""", """Burmese""": """mya_Mymr""", """Dutch""": """nld_Latn""", """Norwegian Nynorsk""": """nno_Latn""", """Norwegian Bokmål""": """nob_Latn""", """Nepali""": """npi_Deva""", """Northern Sotho""": """nso_Latn""", """Nuer""": """nus_Latn""", """Nyanja""": """nya_Latn""", """Occitan""": """oci_Latn""", """West Central Oromo""": """gaz_Latn""", """Odia""": """ory_Orya""", """Pangasinan""": """pag_Latn""", """Eastern Panjabi""": """pan_Guru""", """Papiamento""": """pap_Latn""", """Western Persian""": """pes_Arab""", """Polish""": """pol_Latn""", """Portuguese""": """por_Latn""", """Dari""": """prs_Arab""", """Southern Pashto""": """pbt_Arab""", """Ayacucho Quechua""": """quy_Latn""", """Romanian""": """ron_Latn""", """Rundi""": """run_Latn""", """Russian""": """rus_Cyrl""", """Sango""": """sag_Latn""", """Sanskrit""": """san_Deva""", """Santali""": """sat_Olck""", """Sicilian""": """scn_Latn""", """Shan""": """shn_Mymr""", """Sinhala""": """sin_Sinh""", """Slovak""": """slk_Latn""", """Slovenian""": """slv_Latn""", """Samoan""": """smo_Latn""", """Shona""": """sna_Latn""", """Sindhi""": """snd_Arab""", """Somali""": """som_Latn""", """Southern Sotho""": """sot_Latn""", """Spanish""": """spa_Latn""", """Tosk Albanian""": """als_Latn""", """Sardinian""": """srd_Latn""", """Serbian""": """srp_Cyrl""", """Swati""": """ssw_Latn""", """Sundanese""": """sun_Latn""", """Swedish""": """swe_Latn""", """Swahili""": """swh_Latn""", """Silesian""": """szl_Latn""", """Tamil""": """tam_Taml""", """Tatar""": """tat_Cyrl""", """Telugu""": """tel_Telu""", """Tajik""": """tgk_Cyrl""", """Tagalog""": """tgl_Latn""", """Thai""": """tha_Thai""", """Tigrinya""": """tir_Ethi""", """Tamasheq Latin""": """taq_Latn""", """Tamasheq Tifinagh""": """taq_Tfng""", """Tok Pisin""": """tpi_Latn""", """Tswana""": """tsn_Latn""", """Tsonga""": """tso_Latn""", """Turkmen""": """tuk_Latn""", """Tumbuka""": """tum_Latn""", """Turkish""": """tur_Latn""", """Twi""": """twi_Latn""", """Central Atlas Tamazight""": """tzm_Tfng""", """Uyghur""": """uig_Arab""", """Ukrainian""": """ukr_Cyrl""", """Umbundu""": """umb_Latn""", """Urdu""": """urd_Arab""", """Northern Uzbek""": """uzn_Latn""", """Venetian""": """vec_Latn""", """Vietnamese""": """vie_Latn""", """Waray""": """war_Latn""", """Wolof""": """wol_Latn""", """Xhosa""": """xho_Latn""", """Eastern Yiddish""": """ydd_Hebr""", """Yoruba""": """yor_Latn""", """Yue Chinese""": """yue_Hant""", """Chinese Simplified""": """zho_Hans""", """Chinese Traditional""": """zho_Hant""", """Standard Malay""": """zsm_Latn""", """Zulu""": """zul_Latn""", } class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = "facebook/nllb-200-distilled-600M" __UpperCamelCase = ( "This is a tool that translates text from a language to another. It takes three inputs: `text`, which should " "be the text to translate, `src_lang`, which should be the language of the text to translate and `tgt_lang`, " "which should be the language for the desired ouput language. Both `src_lang` and `tgt_lang` are written in " "plain English, such as 'Romanian', or 'Albanian'. It returns the text translated in `tgt_lang`." ) __UpperCamelCase = "translator" __UpperCamelCase = AutoTokenizer __UpperCamelCase = AutoModelForSeqaSeqLM __UpperCamelCase = LANGUAGE_CODES __UpperCamelCase = ["text", "text", "text"] __UpperCamelCase = ["text"] def _SCREAMING_SNAKE_CASE ( self : List[Any] , lowercase_ : Dict , lowercase_ : str , lowercase_ : str): '''simple docstring''' if src_lang not in self.lang_to_code: raise ValueError(F'{src_lang} is not a supported language.') if tgt_lang not in self.lang_to_code: raise ValueError(F'{tgt_lang} is not a supported language.') SCREAMING_SNAKE_CASE_ : Any = self.lang_to_code[src_lang] SCREAMING_SNAKE_CASE_ : Optional[Any] = self.lang_to_code[tgt_lang] return self.pre_processor._build_translation_inputs( lowercase_ , return_tensors='''pt''' , src_lang=lowercase_ , tgt_lang=lowercase_) def _SCREAMING_SNAKE_CASE ( self : int , lowercase_ : Any): '''simple docstring''' return self.model.generate(**lowercase_) def _SCREAMING_SNAKE_CASE ( self : Dict , lowercase_ : int): '''simple docstring''' return self.post_processor.decode(outputs[0].tolist() , skip_special_tokens=lowercase_)
353
"""simple docstring""" from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCAmelCase_ : Dict = logging.get_logger(__name__) UpperCAmelCase_ : List[str] = { """RWKV/rwkv-4-169m-pile""": """https://huggingface.co/RWKV/rwkv-4-169m-pile/resolve/main/config.json""", """RWKV/rwkv-4-430m-pile""": """https://huggingface.co/RWKV/rwkv-4-430m-pile/resolve/main/config.json""", """RWKV/rwkv-4-1b5-pile""": """https://huggingface.co/RWKV/rwkv-4-1b5-pile/resolve/main/config.json""", """RWKV/rwkv-4-3b-pile""": """https://huggingface.co/RWKV/rwkv-4-3b-pile/resolve/main/config.json""", """RWKV/rwkv-4-7b-pile""": """https://huggingface.co/RWKV/rwkv-4-7b-pile/resolve/main/config.json""", """RWKV/rwkv-4-14b-pile""": """https://huggingface.co/RWKV/rwkv-4-14b-pile/resolve/main/config.json""", """RWKV/rwkv-raven-1b5""": """https://huggingface.co/RWKV/rwkv-raven-1b5/resolve/main/config.json""", """RWKV/rwkv-raven-3b""": """https://huggingface.co/RWKV/rwkv-raven-3b/resolve/main/config.json""", """RWKV/rwkv-raven-7b""": """https://huggingface.co/RWKV/rwkv-raven-7b/resolve/main/config.json""", """RWKV/rwkv-raven-14b""": """https://huggingface.co/RWKV/rwkv-raven-14b/resolve/main/config.json""", } class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = "rwkv" __UpperCamelCase = {"max_position_embeddings": "context_length"} def __init__( self : Union[str, Any] , lowercase_ : Any=50277 , lowercase_ : str=1024 , lowercase_ : List[str]=4096 , lowercase_ : Optional[Any]=32 , lowercase_ : Any=None , lowercase_ : Any=None , lowercase_ : List[Any]=1e-5 , lowercase_ : Union[str, Any]=0 , lowercase_ : Union[str, Any]=0 , lowercase_ : int=6 , lowercase_ : Tuple=False , lowercase_ : Any=True , **lowercase_ : Any , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = vocab_size SCREAMING_SNAKE_CASE_ : Any = context_length SCREAMING_SNAKE_CASE_ : int = hidden_size SCREAMING_SNAKE_CASE_ : int = num_hidden_layers SCREAMING_SNAKE_CASE_ : List[str] = attention_hidden_size if attention_hidden_size is not None else hidden_size SCREAMING_SNAKE_CASE_ : int = intermediate_size if intermediate_size is not None else 4 * hidden_size SCREAMING_SNAKE_CASE_ : int = layer_norm_epsilon SCREAMING_SNAKE_CASE_ : Optional[int] = rescale_every SCREAMING_SNAKE_CASE_ : Dict = use_cache SCREAMING_SNAKE_CASE_ : Dict = bos_token_id SCREAMING_SNAKE_CASE_ : Any = eos_token_id super().__init__( tie_word_embeddings=lowercase_ , bos_token_id=lowercase_ , eos_token_id=lowercase_ , **lowercase_)
318
0
"""simple docstring""" import multiprocessing import time from arguments import PretokenizationArguments from datasets import load_dataset from transformers import AutoTokenizer, HfArgumentParser def _A (__a ) -> List[str]: """simple docstring""" SCREAMING_SNAKE_CASE_ : List[str] = {} SCREAMING_SNAKE_CASE_ : str = tokenizer(example['''content'''] , truncation=__a )['''input_ids'''] SCREAMING_SNAKE_CASE_ : Union[str, Any] = len(example['''content'''] ) / len(output['''input_ids'''] ) return output UpperCAmelCase_ = HfArgumentParser(PretokenizationArguments) UpperCAmelCase_ = parser.parse_args() if args.num_workers is None: UpperCAmelCase_ = multiprocessing.cpu_count() UpperCAmelCase_ = AutoTokenizer.from_pretrained(args.tokenizer_dir) UpperCAmelCase_ = time.time() UpperCAmelCase_ = load_dataset(args.dataset_name, split="""train""") print(f'''Dataset loaded in {time.time()-t_start:.2f}s''') UpperCAmelCase_ = time.time() UpperCAmelCase_ = ds.map( tokenize, num_proc=args.num_workers, remove_columns=[ """repo_name""", """path""", """copies""", """size""", """content""", """license""", """hash""", """line_mean""", """line_max""", """alpha_frac""", """autogenerated""", ], ) print(f'''Dataset tokenized in {time.time()-t_start:.2f}s''') UpperCAmelCase_ = time.time() ds.push_to_hub(args.tokenized_data_repo) print(f'''Data pushed to the hub in {time.time()-t_start:.2f}s''')
354
"""simple docstring""" UpperCAmelCase_ : Optional[int] = 8.3_1_4_4_5_9_8 def _A (__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 UpperCAmelCase_ : str = 300 UpperCAmelCase_ : str = 28 UpperCAmelCase_ : Any = rms_speed_of_molecule(temperature, molar_mass) print(f'''Vrms of Nitrogen gas at 300 K is {vrms} m/s''')
318
0
"""simple docstring""" from __future__ import annotations def _A (__a ) -> int: """simple docstring""" if not nums: return 0 SCREAMING_SNAKE_CASE_ : Union[str, Any] = nums[0] SCREAMING_SNAKE_CASE_ : Optional[int] = 0 for num in nums[1:]: SCREAMING_SNAKE_CASE_ : Union[str, Any] = ( max_excluding + num, max(__a , __a ), ) return max(__a , __a ) if __name__ == "__main__": import doctest doctest.testmod()
355
"""simple docstring""" import json import multiprocessing import os import re from collections import defaultdict import torch from accelerate import Accelerator from accelerate.utils import set_seed from arguments import HumanEvalArguments from datasets import load_dataset, load_metric from torch.utils.data import IterableDataset from torch.utils.data.dataloader import DataLoader from tqdm import tqdm import transformers from transformers import AutoModelForCausalLM, AutoTokenizer, HfArgumentParser, StoppingCriteria, StoppingCriteriaList UpperCAmelCase_ : Union[str, Any] = ["""\nclass""", """\ndef""", """\n#""", """\n@""", """\nprint""", """\nif"""] class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def __init__( self : List[Any] , lowercase_ : Tuple , lowercase_ : Optional[int] , lowercase_ : int=None , lowercase_ : Dict=1): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = tokenizer SCREAMING_SNAKE_CASE_ : Optional[int] = dataset SCREAMING_SNAKE_CASE_ : Optional[Any] = len(lowercase_) if n_tasks is None else n_tasks SCREAMING_SNAKE_CASE_ : Optional[int] = n_copies def __iter__( self : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = [] for task in range(self.n_tasks): # without strip, the model generate commented codes ... prompts.append(self.tokenizer.eos_token + self.dataset[task]['''prompt'''].strip()) SCREAMING_SNAKE_CASE_ : Optional[Any] = self.tokenizer(lowercase_ , padding=lowercase_ , return_tensors='''pt''') for task in range(self.n_tasks): for _ in range(self.n_copies): yield { "ids": outputs.input_ids[task], "task_id": task, "input_len": outputs.attention_mask[task].sum(), } class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def __init__( self : int , lowercase_ : Dict , lowercase_ : Optional[Any] , lowercase_ : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = start_length SCREAMING_SNAKE_CASE_ : List[Any] = eof_strings SCREAMING_SNAKE_CASE_ : List[Any] = tokenizer def __call__( self : Optional[int] , lowercase_ : Any , lowercase_ : int , **lowercase_ : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = self.tokenizer.batch_decode(input_ids[:, self.start_length :]) SCREAMING_SNAKE_CASE_ : Tuple = [] for decoded_generation in decoded_generations: done.append(any(stop_string in decoded_generation for stop_string in self.eof_strings)) return all(lowercase_) def _A (__a ) -> Union[str, Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Dict = re.split('''(%s)''' % '''|'''.join(__a ) , __a ) # last string should be "" return "".join(string_list[:-2] ) def _A (__a , __a , __a , __a , __a , __a=20 , **__a ) -> List[str]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Tuple = defaultdict(__a ) # dict of list of generated tokens for step, batch in tqdm(enumerate(__a ) ): with torch.no_grad(): SCREAMING_SNAKE_CASE_ : Optional[int] = batch['''ids'''].shape[-1] SCREAMING_SNAKE_CASE_ : Tuple = accelerator.unwrap_model(__a ).generate( input_ids=batch['''ids'''][:, : batch['''input_len''']] , num_return_sequences=__a , **__a ) # each task is generated batch_size times SCREAMING_SNAKE_CASE_ : List[Any] = batch['''task_id'''].repeat(__a ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = accelerator.pad_across_processes( __a , dim=1 , pad_index=tokenizer.pad_token_id ) SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Union[str, Any] = accelerator.gather((generated_tokens, generated_tasks) ) SCREAMING_SNAKE_CASE_ : int = generated_tokens.cpu().numpy() SCREAMING_SNAKE_CASE_ : Optional[Any] = generated_tasks.cpu().numpy() for task, generated_tokens in zip(__a , __a ): gen_token_dict[task].append(__a ) SCREAMING_SNAKE_CASE_ : int = [[] for _ in range(__a )] for task, generated_tokens in gen_token_dict.items(): for s in generated_tokens: SCREAMING_SNAKE_CASE_ : Optional[int] = tokenizer.decode(__a , skip_special_tokens=__a , clean_up_tokenization_spaces=__a ) code_gens[task].append(remove_last_block(__a ) ) return code_gens def _A () -> Optional[int]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Union[str, Any] = HfArgumentParser(__a ) SCREAMING_SNAKE_CASE_ : List[Any] = parser.parse_args() transformers.logging.set_verbosity_error() # enables code execution in code_eval metric SCREAMING_SNAKE_CASE_ : Any = args.HF_ALLOW_CODE_EVAL # make sure tokenizer plays nice with multiprocessing SCREAMING_SNAKE_CASE_ : str = '''false''' if args.num_workers is None: SCREAMING_SNAKE_CASE_ : Optional[Any] = multiprocessing.cpu_count() # Use dataset load to feed to accelerate SCREAMING_SNAKE_CASE_ : Tuple = Accelerator() set_seed(args.seed , device_specific=__a ) # Load model and tokenizer SCREAMING_SNAKE_CASE_ : Dict = AutoTokenizer.from_pretrained(args.model_ckpt ) SCREAMING_SNAKE_CASE_ : Dict = tokenizer.eos_token SCREAMING_SNAKE_CASE_ : Optional[int] = AutoModelForCausalLM.from_pretrained(args.model_ckpt ) # Generation settings SCREAMING_SNAKE_CASE_ : List[str] = { '''do_sample''': args.do_sample, '''temperature''': args.temperature, '''max_new_tokens''': args.max_new_tokens, '''top_p''': args.top_p, '''top_k''': args.top_k, '''stopping_criteria''': StoppingCriteriaList([EndOfFunctionCriteria(0 , __a , __a )] ), } # Load evaluation dataset and metric SCREAMING_SNAKE_CASE_ : Optional[int] = load_dataset('''openai_humaneval''' ) SCREAMING_SNAKE_CASE_ : str = load_metric('''code_eval''' ) SCREAMING_SNAKE_CASE_ : int = args.num_tasks if args.num_tasks is not None else len(human_eval['''test'''] ) SCREAMING_SNAKE_CASE_ : List[str] = args.n_samples // args.batch_size SCREAMING_SNAKE_CASE_ : Union[str, Any] = TokenizedDataset(__a , human_eval['''test'''] , n_copies=__a , n_tasks=__a ) # do not confuse args.batch_size, which is actually the num_return_sequences SCREAMING_SNAKE_CASE_ : Optional[int] = DataLoader(__a , batch_size=1 ) # Run a quick test to see if code evaluation is enabled try: SCREAMING_SNAKE_CASE_ : Any = code_eval_metric.compute(references=[''''''] , predictions=[['''''']] ) except ValueError as exception: print( '''Code evaluation not enabled. Read the warning below carefully and then use `--HF_ALLOW_CODE_EVAL="1"`''' ''' flag to enable code evaluation.''' ) raise exception SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : int = accelerator.prepare(__a , __a ) SCREAMING_SNAKE_CASE_ : List[Any] = complete_code( __a , __a , __a , __a , n_tasks=__a , batch_size=args.batch_size , **__a , ) if accelerator.is_main_process: SCREAMING_SNAKE_CASE_ : int = [] for task in tqdm(range(__a ) ): SCREAMING_SNAKE_CASE_ : Tuple = human_eval['''test'''][task]['''test'''] SCREAMING_SNAKE_CASE_ : Tuple = f'check({human_eval["test"][task]["entry_point"]})' references.append('''\n''' + test_func + '''\n''' + entry_point ) # Evaluate completions with "code_eval" metric SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Dict = code_eval_metric.compute( references=__a , predictions=__a , num_workers=args.num_workers ) print(f'Results: {pass_at_k}' ) # Save results to json file with open(args.output_file , '''w''' ) as fp: json.dump(__a , __a ) # For some reason the folliwng seems to be necessary sometimes for code_eval to work nice with multiprocessing # https://stackoverflow.com/questions/60804599/python-multiprocessing-keeps-spawning-the-whole-script if __name__ == "__main__": main()
318
0
"""simple docstring""" import copy from typing import Any, Dict, List, Optional, Union import numpy as np from ...audio_utils import mel_filter_bank, spectrogram, window_function from ...feature_extraction_sequence_utils import SequenceFeatureExtractor from ...feature_extraction_utils import BatchFeature from ...utils import TensorType, logging UpperCAmelCase_ : int = logging.get_logger(__name__) class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = ["input_features"] def __init__( self : int , lowercase_ : str=80 , lowercase_ : Any=16000 , lowercase_ : Any=160 , lowercase_ : int=30 , lowercase_ : Any=400 , lowercase_ : int=0.0 , lowercase_ : Union[str, Any]=False , **lowercase_ : Optional[int] , ): '''simple docstring''' super().__init__( feature_size=lowercase_ , sampling_rate=lowercase_ , padding_value=lowercase_ , return_attention_mask=lowercase_ , **lowercase_ , ) SCREAMING_SNAKE_CASE_ : Tuple = n_fft SCREAMING_SNAKE_CASE_ : Tuple = hop_length SCREAMING_SNAKE_CASE_ : Optional[Any] = chunk_length SCREAMING_SNAKE_CASE_ : int = chunk_length * sampling_rate SCREAMING_SNAKE_CASE_ : Tuple = self.n_samples // hop_length SCREAMING_SNAKE_CASE_ : List[Any] = sampling_rate SCREAMING_SNAKE_CASE_ : Tuple = mel_filter_bank( num_frequency_bins=1 + n_fft // 2 , num_mel_filters=lowercase_ , min_frequency=0.0 , max_frequency=8000.0 , sampling_rate=lowercase_ , norm='''slaney''' , mel_scale='''slaney''' , ) def _SCREAMING_SNAKE_CASE ( self : List[Any] , lowercase_ : np.array): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = spectrogram( lowercase_ , window_function(self.n_fft , '''hann''') , frame_length=self.n_fft , hop_length=self.hop_length , power=2.0 , mel_filters=self.mel_filters , log_mel='''log10''' , ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = log_spec[:, :-1] SCREAMING_SNAKE_CASE_ : Dict = np.maximum(lowercase_ , log_spec.max() - 8.0) SCREAMING_SNAKE_CASE_ : Tuple = (log_spec + 4.0) / 4.0 return log_spec @staticmethod # Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm def _SCREAMING_SNAKE_CASE ( lowercase_ : List[np.ndarray] , lowercase_ : List[np.ndarray] , lowercase_ : float = 0.0): '''simple docstring''' if attention_mask is not None: SCREAMING_SNAKE_CASE_ : Union[str, Any] = np.array(lowercase_ , np.intaa) SCREAMING_SNAKE_CASE_ : List[Any] = [] for vector, length in zip(lowercase_ , attention_mask.sum(-1)): SCREAMING_SNAKE_CASE_ : int = (vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1e-7) if length < normed_slice.shape[0]: SCREAMING_SNAKE_CASE_ : Any = padding_value normed_input_values.append(lowercase_) else: SCREAMING_SNAKE_CASE_ : List[Any] = [(x - x.mean()) / np.sqrt(x.var() + 1e-7) for x in input_values] return normed_input_values def __call__( self : List[Any] , lowercase_ : Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]] , lowercase_ : bool = True , lowercase_ : Optional[int] = None , lowercase_ : Optional[Union[str, TensorType]] = None , lowercase_ : Optional[bool] = None , lowercase_ : Optional[str] = "max_length" , lowercase_ : Optional[int] = None , lowercase_ : Optional[int] = None , lowercase_ : Optional[bool] = None , **lowercase_ : Optional[int] , ): '''simple docstring''' if sampling_rate is not None: if sampling_rate != self.sampling_rate: raise ValueError( F'The model corresponding to this feature extractor: {self.__class__.__name__} was trained using a' F' sampling rate of {self.sampling_rate}. Please make sure that the provided `raw_speech` input' F' was sampled with {self.sampling_rate} and not {sampling_rate}.') else: logger.warning( '''It is strongly recommended to pass the `sampling_rate` argument to this function. ''' '''Failing to do so can result in silent errors that might be hard to debug.''') SCREAMING_SNAKE_CASE_ : Tuple = isinstance(lowercase_ , np.ndarray) and len(raw_speech.shape) > 1 if is_batched_numpy and len(raw_speech.shape) > 2: raise ValueError(F'Only mono-channel audio is supported for input to {self}') SCREAMING_SNAKE_CASE_ : str = is_batched_numpy or ( isinstance(lowercase_ , (list, tuple)) and (isinstance(raw_speech[0] , (np.ndarray, tuple, list))) ) if is_batched: SCREAMING_SNAKE_CASE_ : Optional[Any] = [np.asarray([speech] , dtype=np.floataa).T for speech in raw_speech] elif not is_batched and not isinstance(lowercase_ , np.ndarray): SCREAMING_SNAKE_CASE_ : Tuple = np.asarray(lowercase_ , dtype=np.floataa) elif isinstance(lowercase_ , np.ndarray) and raw_speech.dtype is np.dtype(np.floataa): SCREAMING_SNAKE_CASE_ : Any = raw_speech.astype(np.floataa) # always return batch if not is_batched: SCREAMING_SNAKE_CASE_ : str = [np.asarray([raw_speech]).T] SCREAMING_SNAKE_CASE_ : int = BatchFeature({'''input_features''': raw_speech}) # convert into correct format for padding SCREAMING_SNAKE_CASE_ : Any = self.pad( lowercase_ , padding=lowercase_ , max_length=max_length if max_length else self.n_samples , truncation=lowercase_ , pad_to_multiple_of=lowercase_ , return_attention_mask=return_attention_mask or do_normalize , ) # zero-mean and unit-variance normalization if do_normalize: SCREAMING_SNAKE_CASE_ : Dict = self.zero_mean_unit_var_norm( padded_inputs['''input_features'''] , attention_mask=padded_inputs['''attention_mask'''] , padding_value=self.padding_value , ) SCREAMING_SNAKE_CASE_ : Dict = np.stack(padded_inputs['''input_features'''] , axis=0) # make sure list is in array format SCREAMING_SNAKE_CASE_ : str = padded_inputs.get('''input_features''').transpose(2 , 0 , 1) SCREAMING_SNAKE_CASE_ : List[str] = [self._np_extract_fbank_features(lowercase_) for waveform in input_features[0]] if isinstance(input_features[0] , lowercase_): SCREAMING_SNAKE_CASE_ : str = [np.asarray(lowercase_ , dtype=np.floataa) for feature in input_features] else: SCREAMING_SNAKE_CASE_ : Any = input_features if return_attention_mask: # rescale from sample (48000) to feature (3000) SCREAMING_SNAKE_CASE_ : Tuple = padded_inputs['''attention_mask'''][:, :: self.hop_length] if return_tensors is not None: SCREAMING_SNAKE_CASE_ : Optional[int] = padded_inputs.convert_to_tensors(lowercase_) return padded_inputs def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[str] = copy.deepcopy(self.__dict__) SCREAMING_SNAKE_CASE_ : Tuple = self.__class__.__name__ if "mel_filters" in output: del output["mel_filters"] return output
356
"""simple docstring""" from ...processing_utils import ProcessorMixin class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = ["image_processor", "feature_extractor"] __UpperCamelCase = "TvltImageProcessor" __UpperCamelCase = "TvltFeatureExtractor" def __init__( self : int , lowercase_ : Optional[Any] , lowercase_ : Optional[Any]): '''simple docstring''' super().__init__(image_processor=lowercase_ , feature_extractor=lowercase_) SCREAMING_SNAKE_CASE_ : Union[str, Any] = image_processor SCREAMING_SNAKE_CASE_ : Optional[Any] = feature_extractor def __call__( self : Any , lowercase_ : str=None , lowercase_ : Optional[Any]=None , lowercase_ : Optional[Any]=None , lowercase_ : str=None , lowercase_ : int=False , lowercase_ : Union[str, Any]=False , *lowercase_ : List[Any] , **lowercase_ : List[str] , ): '''simple docstring''' if images is None and audio is None: raise ValueError('''You need to specify either an `images` or `audio` input to process.''') SCREAMING_SNAKE_CASE_ : Any = None if images is not None: SCREAMING_SNAKE_CASE_ : Tuple = self.image_processor(lowercase_ , mask_pixel=lowercase_ , *lowercase_ , **lowercase_) if images_mixed is not None: SCREAMING_SNAKE_CASE_ : Optional[int] = self.image_processor(lowercase_ , is_mixed=lowercase_ , *lowercase_ , **lowercase_) if audio is not None: SCREAMING_SNAKE_CASE_ : Any = self.feature_extractor( lowercase_ , *lowercase_ , sampling_rate=lowercase_ , mask_audio=lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : List[Any] = {} if audio is not None: output_dict.update(lowercase_) if images is not None: output_dict.update(lowercase_) if images_mixed_dict is not None: output_dict.update(lowercase_) return output_dict @property def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = self.image_processor.model_input_names SCREAMING_SNAKE_CASE_ : Dict = self.feature_extractor.model_input_names return list(dict.fromkeys(image_processor_input_names + feature_extractor_input_names))
318
0
"""simple docstring""" import unittest import numpy as np import requests from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): import torch from transformers.pytorch_utils import is_torch_greater_or_equal_than_1_11 else: UpperCAmelCase_ : Tuple = False if is_vision_available(): from PIL import Image from transformers import PixaStructImageProcessor class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' def __init__( self : Optional[int] , lowercase_ : Optional[int] , lowercase_ : int=7 , lowercase_ : str=3 , lowercase_ : str=18 , lowercase_ : Dict=30 , lowercase_ : int=400 , lowercase_ : Any=None , lowercase_ : List[str]=True , lowercase_ : Optional[Any]=True , lowercase_ : Any=None , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = size if size is not None else {'''height''': 20, '''width''': 20} SCREAMING_SNAKE_CASE_ : List[str] = parent SCREAMING_SNAKE_CASE_ : int = batch_size SCREAMING_SNAKE_CASE_ : str = num_channels SCREAMING_SNAKE_CASE_ : Optional[int] = image_size SCREAMING_SNAKE_CASE_ : Optional[int] = min_resolution SCREAMING_SNAKE_CASE_ : Union[str, Any] = max_resolution SCREAMING_SNAKE_CASE_ : Dict = size SCREAMING_SNAKE_CASE_ : Any = do_normalize SCREAMING_SNAKE_CASE_ : str = do_convert_rgb SCREAMING_SNAKE_CASE_ : Any = [512, 1024, 2048, 4096] SCREAMING_SNAKE_CASE_ : Dict = patch_size if patch_size is not None else {'''height''': 16, '''width''': 16} def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' return {"do_normalize": self.do_normalize, "do_convert_rgb": self.do_convert_rgb} def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = '''https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/australia.jpg''' SCREAMING_SNAKE_CASE_ : Any = Image.open(requests.get(lowercase_ , stream=lowercase_).raw).convert('''RGB''') return raw_image @unittest.skipIf( not is_torch_greater_or_equal_than_1_11 , reason="`Pix2StructImageProcessor` requires `torch>=1.11.0`." , ) @require_torch @require_vision class lowerCAmelCase__ ( UpperCAmelCase__ , unittest.TestCase ): '''simple docstring''' __UpperCamelCase = PixaStructImageProcessor if is_vision_available() else None def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[str] = PixaStructImageProcessingTester(self) @property def _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' return self.image_processor_tester.prepare_image_processor_dict() def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = self.image_processing_class(**self.image_processor_dict) self.assertTrue(hasattr(lowercase_ , '''do_normalize''')) self.assertTrue(hasattr(lowercase_ , '''do_convert_rgb''')) def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = self.image_processor_tester.prepare_dummy_image() SCREAMING_SNAKE_CASE_ : List[Any] = self.image_processing_class(**self.image_processor_dict) SCREAMING_SNAKE_CASE_ : Any = 2048 SCREAMING_SNAKE_CASE_ : Dict = image_processor(lowercase_ , return_tensors='''pt''' , max_patches=lowercase_) self.assertTrue(torch.allclose(inputs.flattened_patches.mean() , torch.tensor(0.06_06) , atol=1e-3 , rtol=1e-3)) def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = self.image_processing_class(**self.image_processor_dict) # create random PIL images SCREAMING_SNAKE_CASE_ : str = prepare_image_inputs(self.image_processor_tester , equal_resolution=lowercase_) for image in image_inputs: self.assertIsInstance(lowercase_ , Image.Image) # Test not batched input SCREAMING_SNAKE_CASE_ : Tuple = ( (self.image_processor_tester.patch_size['''height'''] * self.image_processor_tester.patch_size['''width''']) * self.image_processor_tester.num_channels ) + 2 for max_patch in self.image_processor_tester.max_patches: # Test not batched input SCREAMING_SNAKE_CASE_ : List[Any] = image_processor( image_inputs[0] , return_tensors='''pt''' , max_patches=lowercase_).flattened_patches self.assertEqual( encoded_images.shape , (1, max_patch, expected_hidden_dim) , ) # Test batched SCREAMING_SNAKE_CASE_ : Optional[Any] = image_processor( lowercase_ , return_tensors='''pt''' , max_patches=lowercase_).flattened_patches self.assertEqual( encoded_images.shape , (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim) , ) def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = self.image_processing_class(**self.image_processor_dict) # create random PIL images SCREAMING_SNAKE_CASE_ : int = prepare_image_inputs(self.image_processor_tester , equal_resolution=lowercase_) for image in image_inputs: self.assertIsInstance(lowercase_ , Image.Image) # Test not batched input SCREAMING_SNAKE_CASE_ : Optional[Any] = ( (self.image_processor_tester.patch_size['''height'''] * self.image_processor_tester.patch_size['''width''']) * self.image_processor_tester.num_channels ) + 2 SCREAMING_SNAKE_CASE_ : List[str] = True for max_patch in self.image_processor_tester.max_patches: # Test not batched input with self.assertRaises(lowercase_): SCREAMING_SNAKE_CASE_ : Tuple = image_processor( image_inputs[0] , return_tensors='''pt''' , max_patches=lowercase_).flattened_patches SCREAMING_SNAKE_CASE_ : List[Any] = '''Hello''' SCREAMING_SNAKE_CASE_ : Optional[Any] = image_processor( image_inputs[0] , return_tensors='''pt''' , max_patches=lowercase_ , header_text=lowercase_).flattened_patches self.assertEqual( encoded_images.shape , (1, max_patch, expected_hidden_dim) , ) # Test batched SCREAMING_SNAKE_CASE_ : List[str] = image_processor( lowercase_ , return_tensors='''pt''' , max_patches=lowercase_ , header_text=lowercase_).flattened_patches self.assertEqual( encoded_images.shape , (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim) , ) def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors SCREAMING_SNAKE_CASE_ : Any = prepare_image_inputs(self.image_processor_tester , equal_resolution=lowercase_ , numpify=lowercase_) for image in image_inputs: self.assertIsInstance(lowercase_ , np.ndarray) SCREAMING_SNAKE_CASE_ : Optional[int] = ( (self.image_processor_tester.patch_size['''height'''] * self.image_processor_tester.patch_size['''width''']) * self.image_processor_tester.num_channels ) + 2 for max_patch in self.image_processor_tester.max_patches: # Test not batched input SCREAMING_SNAKE_CASE_ : Union[str, Any] = image_processor( image_inputs[0] , return_tensors='''pt''' , max_patches=lowercase_).flattened_patches self.assertEqual( encoded_images.shape , (1, max_patch, expected_hidden_dim) , ) # Test batched SCREAMING_SNAKE_CASE_ : Tuple = image_processor( lowercase_ , return_tensors='''pt''' , max_patches=lowercase_).flattened_patches self.assertEqual( encoded_images.shape , (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim) , ) def _SCREAMING_SNAKE_CASE ( self : Any): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors SCREAMING_SNAKE_CASE_ : Tuple = prepare_image_inputs(self.image_processor_tester , equal_resolution=lowercase_ , torchify=lowercase_) for image in image_inputs: self.assertIsInstance(lowercase_ , torch.Tensor) # Test not batched input SCREAMING_SNAKE_CASE_ : Union[str, Any] = ( (self.image_processor_tester.patch_size['''height'''] * self.image_processor_tester.patch_size['''width''']) * self.image_processor_tester.num_channels ) + 2 for max_patch in self.image_processor_tester.max_patches: # Test not batched input SCREAMING_SNAKE_CASE_ : Tuple = image_processor( image_inputs[0] , return_tensors='''pt''' , max_patches=lowercase_).flattened_patches self.assertEqual( encoded_images.shape , (1, max_patch, expected_hidden_dim) , ) # Test batched SCREAMING_SNAKE_CASE_ : Tuple = image_processor( lowercase_ , return_tensors='''pt''' , max_patches=lowercase_).flattened_patches self.assertEqual( encoded_images.shape , (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim) , ) @unittest.skipIf( not is_torch_greater_or_equal_than_1_11 , reason="`Pix2StructImageProcessor` requires `torch>=1.11.0`." , ) @require_torch @require_vision class lowerCAmelCase__ ( UpperCAmelCase__ , unittest.TestCase ): '''simple docstring''' __UpperCamelCase = PixaStructImageProcessor if is_vision_available() else None def _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = PixaStructImageProcessingTester(self , num_channels=4) SCREAMING_SNAKE_CASE_ : List[str] = 3 @property def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' return self.image_processor_tester.prepare_image_processor_dict() def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = self.image_processing_class(**self.image_processor_dict) self.assertTrue(hasattr(lowercase_ , '''do_normalize''')) self.assertTrue(hasattr(lowercase_ , '''do_convert_rgb''')) def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = self.image_processing_class(**self.image_processor_dict) # create random PIL images SCREAMING_SNAKE_CASE_ : Tuple = prepare_image_inputs(self.image_processor_tester , equal_resolution=lowercase_) for image in image_inputs: self.assertIsInstance(lowercase_ , Image.Image) # Test not batched input SCREAMING_SNAKE_CASE_ : Optional[int] = ( (self.image_processor_tester.patch_size['''height'''] * self.image_processor_tester.patch_size['''width''']) * (self.image_processor_tester.num_channels - 1) ) + 2 for max_patch in self.image_processor_tester.max_patches: # Test not batched input SCREAMING_SNAKE_CASE_ : Optional[Any] = image_processor( image_inputs[0] , return_tensors='''pt''' , max_patches=lowercase_).flattened_patches self.assertEqual( encoded_images.shape , (1, max_patch, expected_hidden_dim) , ) # Test batched SCREAMING_SNAKE_CASE_ : Dict = image_processor( lowercase_ , return_tensors='''pt''' , max_patches=lowercase_).flattened_patches self.assertEqual( encoded_images.shape , (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim) , )
357
"""simple docstring""" from ...processing_utils import ProcessorMixin class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = "SpeechT5FeatureExtractor" __UpperCamelCase = "SpeechT5Tokenizer" def __init__( self : Any , lowercase_ : Dict , lowercase_ : Optional[Any]): '''simple docstring''' super().__init__(lowercase_ , lowercase_) def __call__( self : List[Any] , *lowercase_ : List[Any] , **lowercase_ : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[str] = kwargs.pop('''audio''' , lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = kwargs.pop('''text''' , lowercase_) SCREAMING_SNAKE_CASE_ : Any = kwargs.pop('''text_target''' , lowercase_) SCREAMING_SNAKE_CASE_ : Dict = kwargs.pop('''audio_target''' , lowercase_) SCREAMING_SNAKE_CASE_ : List[Any] = kwargs.pop('''sampling_rate''' , lowercase_) if audio is not None and text is not None: raise ValueError( '''Cannot process both `audio` and `text` inputs. Did you mean `audio_target` or `text_target`?''') if audio_target is not None and text_target is not None: raise ValueError( '''Cannot process both `audio_target` and `text_target` inputs. Did you mean `audio` or `text`?''') if audio is None and audio_target is None and text is None and text_target is None: raise ValueError( '''You need to specify either an `audio`, `audio_target`, `text`, or `text_target` input to process.''') if audio is not None: SCREAMING_SNAKE_CASE_ : Any = self.feature_extractor(lowercase_ , *lowercase_ , sampling_rate=lowercase_ , **lowercase_) elif text is not None: SCREAMING_SNAKE_CASE_ : Dict = self.tokenizer(lowercase_ , **lowercase_) else: SCREAMING_SNAKE_CASE_ : Any = None if audio_target is not None: SCREAMING_SNAKE_CASE_ : List[Any] = self.feature_extractor(audio_target=lowercase_ , *lowercase_ , sampling_rate=lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = targets['''input_values'''] elif text_target is not None: SCREAMING_SNAKE_CASE_ : int = self.tokenizer(lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : List[Any] = targets['''input_ids'''] else: SCREAMING_SNAKE_CASE_ : int = None if inputs is None: return targets if targets is not None: SCREAMING_SNAKE_CASE_ : Union[str, Any] = labels SCREAMING_SNAKE_CASE_ : Optional[Any] = targets.get('''attention_mask''') if decoder_attention_mask is not None: SCREAMING_SNAKE_CASE_ : Any = decoder_attention_mask return inputs def _SCREAMING_SNAKE_CASE ( self : Tuple , *lowercase_ : Tuple , **lowercase_ : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = kwargs.pop('''input_values''' , lowercase_) SCREAMING_SNAKE_CASE_ : int = kwargs.pop('''input_ids''' , lowercase_) SCREAMING_SNAKE_CASE_ : Dict = kwargs.pop('''labels''' , lowercase_) if input_values is not None and input_ids is not None: raise ValueError('''Cannot process both `input_values` and `input_ids` inputs.''') if input_values is None and input_ids is None and labels is None: raise ValueError( '''You need to specify either an `input_values`, `input_ids`, or `labels` input to be padded.''') if input_values is not None: SCREAMING_SNAKE_CASE_ : Any = self.feature_extractor.pad(lowercase_ , *lowercase_ , **lowercase_) elif input_ids is not None: SCREAMING_SNAKE_CASE_ : Tuple = self.tokenizer.pad(lowercase_ , **lowercase_) else: SCREAMING_SNAKE_CASE_ : List[Any] = None if labels is not None: if "input_ids" in labels or (isinstance(lowercase_ , lowercase_) and "input_ids" in labels[0]): SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.tokenizer.pad(lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : Dict = targets['''input_ids'''] else: SCREAMING_SNAKE_CASE_ : Dict = self.feature_extractor.feature_size SCREAMING_SNAKE_CASE_ : Optional[int] = self.feature_extractor.num_mel_bins SCREAMING_SNAKE_CASE_ : str = self.feature_extractor.pad(lowercase_ , *lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : str = feature_size_hack SCREAMING_SNAKE_CASE_ : Dict = targets['''input_values'''] else: SCREAMING_SNAKE_CASE_ : List[Any] = None if inputs is None: return targets if targets is not None: SCREAMING_SNAKE_CASE_ : Dict = labels SCREAMING_SNAKE_CASE_ : List[str] = targets.get('''attention_mask''') if decoder_attention_mask is not None: SCREAMING_SNAKE_CASE_ : Optional[Any] = decoder_attention_mask return inputs def _SCREAMING_SNAKE_CASE ( self : Optional[Any] , *lowercase_ : Optional[int] , **lowercase_ : Tuple): '''simple docstring''' return self.tokenizer.batch_decode(*lowercase_ , **lowercase_) def _SCREAMING_SNAKE_CASE ( self : List[Any] , *lowercase_ : Dict , **lowercase_ : List[Any]): '''simple docstring''' return self.tokenizer.decode(*lowercase_ , **lowercase_)
318
0
"""simple docstring""" from .glue import GlueDataset, GlueDataTrainingArguments from .language_modeling import ( LineByLineTextDataset, LineByLineWithRefDataset, LineByLineWithSOPTextDataset, TextDataset, TextDatasetForNextSentencePrediction, ) from .squad import SquadDataset, SquadDataTrainingArguments
358
"""simple docstring""" import os from typing import BinaryIO, Optional, Union import numpy as np import pyarrow.parquet as pq from .. import Audio, Dataset, Features, Image, NamedSplit, Value, config from ..features.features import FeatureType, _visit from ..formatting import query_table from ..packaged_modules import _PACKAGED_DATASETS_MODULES from ..packaged_modules.parquet.parquet import Parquet from ..utils import logging from ..utils.typing import NestedDataStructureLike, PathLike from .abc import AbstractDatasetReader def _A (__a ) -> Optional[int]: """simple docstring""" SCREAMING_SNAKE_CASE_ : List[str] = np.inf def set_batch_size(__a ) -> None: nonlocal batch_size if isinstance(__a , __a ): SCREAMING_SNAKE_CASE_ : Tuple = min(__a , config.PARQUET_ROW_GROUP_SIZE_FOR_IMAGE_DATASETS ) elif isinstance(__a , __a ): SCREAMING_SNAKE_CASE_ : int = min(__a , config.PARQUET_ROW_GROUP_SIZE_FOR_AUDIO_DATASETS ) elif isinstance(__a , __a ) and feature.dtype == "binary": SCREAMING_SNAKE_CASE_ : Union[str, Any] = min(__a , config.PARQUET_ROW_GROUP_SIZE_FOR_BINARY_DATASETS ) _visit(__a , __a ) return None if batch_size is np.inf else batch_size class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def __init__( self : Any , lowercase_ : NestedDataStructureLike[PathLike] , lowercase_ : Optional[NamedSplit] = None , lowercase_ : Optional[Features] = None , lowercase_ : str = None , lowercase_ : bool = False , lowercase_ : bool = False , lowercase_ : Optional[int] = None , **lowercase_ : Optional[int] , ): '''simple docstring''' super().__init__( lowercase_ , split=lowercase_ , features=lowercase_ , cache_dir=lowercase_ , keep_in_memory=lowercase_ , streaming=lowercase_ , num_proc=lowercase_ , **lowercase_ , ) SCREAMING_SNAKE_CASE_ : Any = path_or_paths if isinstance(lowercase_ , lowercase_) else {self.split: path_or_paths} SCREAMING_SNAKE_CASE_ : Any = _PACKAGED_DATASETS_MODULES['''parquet'''][1] SCREAMING_SNAKE_CASE_ : Union[str, Any] = Parquet( cache_dir=lowercase_ , data_files=lowercase_ , features=lowercase_ , hash=lowercase_ , **lowercase_ , ) def _SCREAMING_SNAKE_CASE ( self : Tuple): '''simple docstring''' if self.streaming: SCREAMING_SNAKE_CASE_ : str = self.builder.as_streaming_dataset(split=self.split) # Build regular (map-style) dataset else: SCREAMING_SNAKE_CASE_ : Optional[Any] = None SCREAMING_SNAKE_CASE_ : Optional[int] = None SCREAMING_SNAKE_CASE_ : Tuple = None SCREAMING_SNAKE_CASE_ : Dict = None self.builder.download_and_prepare( download_config=lowercase_ , download_mode=lowercase_ , verification_mode=lowercase_ , base_path=lowercase_ , num_proc=self.num_proc , ) SCREAMING_SNAKE_CASE_ : Any = self.builder.as_dataset( split=self.split , verification_mode=lowercase_ , in_memory=self.keep_in_memory) return dataset class lowerCAmelCase__ : '''simple docstring''' def __init__( self : Tuple , lowercase_ : Dataset , lowercase_ : Union[PathLike, BinaryIO] , lowercase_ : Optional[int] = None , **lowercase_ : Dict , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = dataset SCREAMING_SNAKE_CASE_ : Dict = path_or_buf SCREAMING_SNAKE_CASE_ : List[Any] = batch_size or get_writer_batch_size(dataset.features) SCREAMING_SNAKE_CASE_ : Any = parquet_writer_kwargs def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[str] = self.batch_size if self.batch_size else config.DEFAULT_MAX_BATCH_SIZE if isinstance(self.path_or_buf , (str, bytes, os.PathLike)): with open(self.path_or_buf , '''wb+''') as buffer: SCREAMING_SNAKE_CASE_ : Optional[Any] = self._write(file_obj=lowercase_ , batch_size=lowercase_ , **self.parquet_writer_kwargs) else: SCREAMING_SNAKE_CASE_ : str = self._write(file_obj=self.path_or_buf , batch_size=lowercase_ , **self.parquet_writer_kwargs) return written def _SCREAMING_SNAKE_CASE ( self : Tuple , lowercase_ : BinaryIO , lowercase_ : int , **lowercase_ : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = 0 SCREAMING_SNAKE_CASE_ : Optional[int] = parquet_writer_kwargs.pop('''path_or_buf''' , lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = self.dataset.features.arrow_schema SCREAMING_SNAKE_CASE_ : Tuple = pq.ParquetWriter(lowercase_ , schema=lowercase_ , **lowercase_) for offset in logging.tqdm( range(0 , len(self.dataset) , lowercase_) , unit='''ba''' , disable=not logging.is_progress_bar_enabled() , desc='''Creating parquet from Arrow format''' , ): SCREAMING_SNAKE_CASE_ : List[Any] = query_table( table=self.dataset._data , key=slice(lowercase_ , offset + batch_size) , indices=self.dataset._indices if self.dataset._indices is not None else None , ) writer.write_table(lowercase_) written += batch.nbytes writer.close() return written
318
0
"""simple docstring""" from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCAmelCase_ : Any = logging.get_logger(__name__) UpperCAmelCase_ : Dict = { # See all MEGATRON_BERT models at https://huggingface.co/models?filter=bert } class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = "megatron-bert" def __init__( self : Dict , lowercase_ : List[Any]=29056 , lowercase_ : Union[str, Any]=1024 , lowercase_ : Any=24 , lowercase_ : Dict=16 , lowercase_ : List[str]=4096 , lowercase_ : Union[str, Any]="gelu" , lowercase_ : Optional[int]=0.1 , lowercase_ : Any=0.1 , lowercase_ : Any=512 , lowercase_ : Tuple=2 , lowercase_ : Optional[Any]=0.02 , lowercase_ : Any=1e-12 , lowercase_ : Union[str, Any]=0 , lowercase_ : Dict="absolute" , lowercase_ : List[str]=True , **lowercase_ : Any , ): '''simple docstring''' super().__init__(pad_token_id=lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = vocab_size SCREAMING_SNAKE_CASE_ : List[str] = hidden_size SCREAMING_SNAKE_CASE_ : str = num_hidden_layers SCREAMING_SNAKE_CASE_ : Dict = num_attention_heads SCREAMING_SNAKE_CASE_ : Dict = hidden_act SCREAMING_SNAKE_CASE_ : Any = intermediate_size SCREAMING_SNAKE_CASE_ : int = hidden_dropout_prob SCREAMING_SNAKE_CASE_ : List[Any] = attention_probs_dropout_prob SCREAMING_SNAKE_CASE_ : List[Any] = max_position_embeddings SCREAMING_SNAKE_CASE_ : Dict = type_vocab_size SCREAMING_SNAKE_CASE_ : Union[str, Any] = initializer_range SCREAMING_SNAKE_CASE_ : Optional[int] = layer_norm_eps SCREAMING_SNAKE_CASE_ : Union[str, Any] = position_embedding_type SCREAMING_SNAKE_CASE_ : int = use_cache
359
"""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() UpperCAmelCase_ : str = logging.get_logger(__name__) UpperCAmelCase_ : Optional[Any] = ["""model.decoder.embed_positions.weights"""] def _A (__a ) -> Dict: """simple docstring""" if "emb" in name: SCREAMING_SNAKE_CASE_ : Optional[int] = name.replace('''emb''' , '''model.decoder.embed_tokens''' ) if "transformer" in name: SCREAMING_SNAKE_CASE_ : Tuple = name.replace('''transformer''' , '''model.decoder''' ) if "cross_attention" in name: SCREAMING_SNAKE_CASE_ : str = name.replace('''cross_attention''' , '''encoder_attn''' ) if "linear1" in name: SCREAMING_SNAKE_CASE_ : Optional[int] = name.replace('''linear1''' , '''fc1''' ) if "linear2" in name: SCREAMING_SNAKE_CASE_ : str = name.replace('''linear2''' , '''fc2''' ) if "norm1" in name: SCREAMING_SNAKE_CASE_ : Any = name.replace('''norm1''' , '''self_attn_layer_norm''' ) if "norm_cross" in name: SCREAMING_SNAKE_CASE_ : List[str] = name.replace('''norm_cross''' , '''encoder_attn_layer_norm''' ) if "norm2" in name: SCREAMING_SNAKE_CASE_ : Tuple = name.replace('''norm2''' , '''final_layer_norm''' ) if "out_norm" in name: SCREAMING_SNAKE_CASE_ : List[str] = name.replace('''out_norm''' , '''model.decoder.layer_norm''' ) if "linears" in name: SCREAMING_SNAKE_CASE_ : Dict = name.replace('''linears''' , '''lm_heads''' ) if "condition_provider.conditioners.description.output_proj" in name: SCREAMING_SNAKE_CASE_ : List[str] = name.replace('''condition_provider.conditioners.description.output_proj''' , '''enc_to_dec_proj''' ) return name def _A (__a , __a ) -> Tuple[Dict, Dict]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Union[str, Any] = list(state_dict.keys() ) SCREAMING_SNAKE_CASE_ : int = {} for key in keys: SCREAMING_SNAKE_CASE_ : int = state_dict.pop(__a ) SCREAMING_SNAKE_CASE_ : int = rename_keys(__a ) if "in_proj_weight" in key: # split fused qkv proj SCREAMING_SNAKE_CASE_ : List[str] = val[:hidden_size, :] SCREAMING_SNAKE_CASE_ : List[str] = val[hidden_size : 2 * hidden_size, :] SCREAMING_SNAKE_CASE_ : Optional[Any] = val[-hidden_size:, :] elif "enc_to_dec_proj" in key: SCREAMING_SNAKE_CASE_ : int = val else: SCREAMING_SNAKE_CASE_ : Any = val return state_dict, enc_dec_proj_state_dict def _A (__a ) -> MusicgenDecoderConfig: """simple docstring""" if checkpoint == "small": # default config values SCREAMING_SNAKE_CASE_ : Optional[int] = 10_24 SCREAMING_SNAKE_CASE_ : Tuple = 24 SCREAMING_SNAKE_CASE_ : Optional[Any] = 16 elif checkpoint == "medium": SCREAMING_SNAKE_CASE_ : List[str] = 15_36 SCREAMING_SNAKE_CASE_ : Optional[int] = 48 SCREAMING_SNAKE_CASE_ : Optional[int] = 24 elif checkpoint == "large": SCREAMING_SNAKE_CASE_ : Optional[Any] = 20_48 SCREAMING_SNAKE_CASE_ : Optional[int] = 48 SCREAMING_SNAKE_CASE_ : int = 32 else: raise ValueError(f'Checkpoint should be one of `[\'small\', \'medium\', \'large\']`, got {checkpoint}.' ) SCREAMING_SNAKE_CASE_ : List[Any] = MusicgenDecoderConfig( hidden_size=__a , ffn_dim=hidden_size * 4 , num_hidden_layers=__a , num_attention_heads=__a , ) return config @torch.no_grad() def _A (__a , __a=None , __a=None , __a="cpu" ) -> List[str]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Any = MusicGen.get_pretrained(__a , device=__a ) SCREAMING_SNAKE_CASE_ : Dict = decoder_config_from_checkpoint(__a ) SCREAMING_SNAKE_CASE_ : Optional[Any] = fairseq_model.lm.state_dict() SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : int = rename_state_dict( __a , hidden_size=decoder_config.hidden_size ) SCREAMING_SNAKE_CASE_ : Optional[Any] = TaEncoderModel.from_pretrained('''t5-base''' ) SCREAMING_SNAKE_CASE_ : List[str] = EncodecModel.from_pretrained('''facebook/encodec_32khz''' ) SCREAMING_SNAKE_CASE_ : int = MusicgenForCausalLM(__a ).eval() # load all decoder weights - expect that we'll be missing embeddings and enc-dec projection SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : List[str] = decoder.load_state_dict(__a , strict=__a ) for key in missing_keys.copy(): if key.startswith(('''text_encoder''', '''audio_encoder''') ) or key in EXPECTED_MISSING_KEYS: missing_keys.remove(__a ) if len(__a ) > 0: raise ValueError(f'Missing key(s) in state_dict: {missing_keys}' ) if len(__a ) > 0: raise ValueError(f'Unexpected key(s) in state_dict: {unexpected_keys}' ) # init the composite model SCREAMING_SNAKE_CASE_ : str = MusicgenForConditionalGeneration(text_encoder=__a , audio_encoder=__a , decoder=__a ) # load the pre-trained enc-dec projection (from the decoder state dict) model.enc_to_dec_proj.load_state_dict(__a ) # check we can do a forward pass SCREAMING_SNAKE_CASE_ : Dict = torch.arange(0 , 8 , dtype=torch.long ).reshape(2 , -1 ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = input_ids.reshape(2 * 4 , -1 ) with torch.no_grad(): SCREAMING_SNAKE_CASE_ : List[Any] = model(input_ids=__a , decoder_input_ids=__a ).logits if logits.shape != (8, 1, 20_48): raise ValueError('''Incorrect shape for logits''' ) # now construct the processor SCREAMING_SNAKE_CASE_ : str = AutoTokenizer.from_pretrained('''t5-base''' ) SCREAMING_SNAKE_CASE_ : str = AutoFeatureExtractor.from_pretrained('''facebook/encodec_32khz''' , padding_side='''left''' ) SCREAMING_SNAKE_CASE_ : Tuple = MusicgenProcessor(feature_extractor=__a , tokenizer=__a ) # set the appropriate bos/pad token ids SCREAMING_SNAKE_CASE_ : str = 20_48 SCREAMING_SNAKE_CASE_ : List[Any] = 20_48 # set other default generation config params SCREAMING_SNAKE_CASE_ : int = int(30 * audio_encoder.config.frame_rate ) SCREAMING_SNAKE_CASE_ : str = True SCREAMING_SNAKE_CASE_ : Optional[Any] = 3.0 if pytorch_dump_folder is not None: Path(__a ).mkdir(exist_ok=__a ) logger.info(f'Saving model {checkpoint} to {pytorch_dump_folder}' ) model.save_pretrained(__a ) processor.save_pretrained(__a ) if repo_id: logger.info(f'Pushing model {checkpoint} to {repo_id}' ) model.push_to_hub(__a ) processor.push_to_hub(__a ) if __name__ == "__main__": UpperCAmelCase_ : Dict = 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.""" ) UpperCAmelCase_ : Dict = parser.parse_args() convert_musicgen_checkpoint(args.checkpoint, args.pytorch_dump_folder, args.push_to_hub)
318
0
def _A (__a , __a , __a ) -> float: """simple docstring""" if principal <= 0: raise Exception('''Principal borrowed must be > 0''' ) if rate_per_annum < 0: raise Exception('''Rate of interest must be >= 0''' ) if years_to_repay <= 0 or not isinstance(__a , __a ): raise Exception('''Years to repay must be an integer > 0''' ) # Yearly rate is divided by 12 to get monthly rate SCREAMING_SNAKE_CASE_ : Any = rate_per_annum / 12 # Years to repay is multiplied by 12 to get number of payments as payment is monthly SCREAMING_SNAKE_CASE_ : Union[str, Any] = years_to_repay * 12 return ( principal * rate_per_month * (1 + rate_per_month) ** number_of_payments / ((1 + rate_per_month) ** number_of_payments - 1) ) if __name__ == "__main__": import doctest doctest.testmod()
360
"""simple docstring""" from pathlib import Path import numpy as np from PIL import Image def _A (__a ) -> np.ndarray: """simple docstring""" SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Optional[int] = rgb[:, :, 0], rgb[:, :, 1], rgb[:, :, 2] return 0.29_89 * r + 0.58_70 * g + 0.11_40 * b def _A (__a ) -> np.ndarray: """simple docstring""" return (gray > 1_27) & (gray <= 2_55) def _A (__a , __a ) -> np.ndarray: """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[Any] = np.zeros_like(__a ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = np.zeros( (image.shape[0] + kernel.shape[0] - 1, image.shape[1] + kernel.shape[1] - 1) ) # Copy image to padded image SCREAMING_SNAKE_CASE_ : Union[str, Any] = image # Iterate over image & apply kernel for x in range(image.shape[1] ): for y in range(image.shape[0] ): SCREAMING_SNAKE_CASE_ : Optional[Any] = ( kernel * image_padded[y : y + kernel.shape[0], x : x + kernel.shape[1]] ).sum() SCREAMING_SNAKE_CASE_ : Any = int(summation > 0 ) return output if __name__ == "__main__": # read original image UpperCAmelCase_ : Dict = Path(__file__).resolve().parent / """image_data""" / """lena.jpg""" UpperCAmelCase_ : List[Any] = np.array(Image.open(lena_path)) # kernel to be applied UpperCAmelCase_ : Any = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]]) UpperCAmelCase_ : Tuple = dilation(gray_to_binary(rgb_to_gray(lena)), structuring_element) # Save the output image UpperCAmelCase_ : List[str] = Image.fromarray(output).convert("""RGB""") pil_img.save("""result_dilation.png""")
318
0
"""simple docstring""" import argparse from collections import defaultdict import yaml UpperCAmelCase_ = """docs/source/en/_toctree.yml""" def _A (__a ) -> Union[str, Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : str = defaultdict(__a ) for doc in model_doc: counts[doc["local"]] += 1 SCREAMING_SNAKE_CASE_ : List[Any] = [key for key, value in counts.items() if value > 1] SCREAMING_SNAKE_CASE_ : int = [] for duplicate_key in duplicates: SCREAMING_SNAKE_CASE_ : List[str] = list({doc['''title'''] for doc in model_doc if doc['''local'''] == duplicate_key} ) if len(__a ) > 1: raise ValueError( f'{duplicate_key} is present several times in the documentation table of content at ' '''`docs/source/en/_toctree.yml` with different *Title* values. Choose one of those and remove the ''' '''others.''' ) # Only add this once new_doc.append({'''local''': duplicate_key, '''title''': titles[0]} ) # Add none duplicate-keys new_doc.extend([doc for doc in model_doc if counts[doc['''local''']] == 1] ) # Sort return sorted(__a , key=lambda __a : s["title"].lower() ) def _A (__a=False ) -> Tuple: """simple docstring""" with open(__a , encoding='''utf-8''' ) as f: SCREAMING_SNAKE_CASE_ : Dict = yaml.safe_load(f.read() ) # Get to the API doc SCREAMING_SNAKE_CASE_ : Any = 0 while content[api_idx]["title"] != "API": api_idx += 1 SCREAMING_SNAKE_CASE_ : str = content[api_idx]['''sections'''] # Then to the model doc SCREAMING_SNAKE_CASE_ : List[Any] = 0 while api_doc[model_idx]["title"] != "Models": model_idx += 1 SCREAMING_SNAKE_CASE_ : Optional[int] = api_doc[model_idx]['''sections'''] SCREAMING_SNAKE_CASE_ : str = [(idx, section) for idx, section in enumerate(__a ) if '''sections''' in section] SCREAMING_SNAKE_CASE_ : Optional[Any] = False for idx, modality_doc in modalities_docs: SCREAMING_SNAKE_CASE_ : List[str] = modality_doc['''sections'''] SCREAMING_SNAKE_CASE_ : Union[str, Any] = clean_model_doc_toc(__a ) if old_modality_doc != new_modality_doc: SCREAMING_SNAKE_CASE_ : str = True if overwrite: SCREAMING_SNAKE_CASE_ : Optional[int] = new_modality_doc if diff: if overwrite: SCREAMING_SNAKE_CASE_ : List[Any] = model_doc SCREAMING_SNAKE_CASE_ : int = api_doc with open(__a , '''w''' , encoding='''utf-8''' ) as f: f.write(yaml.dump(__a , allow_unicode=__a ) ) else: raise ValueError( '''The model doc part of the table of content is not properly sorted, run `make style` to fix this.''' ) if __name__ == "__main__": UpperCAmelCase_ = argparse.ArgumentParser() parser.add_argument("""--fix_and_overwrite""", action="""store_true""", help="""Whether to fix inconsistencies.""") UpperCAmelCase_ = parser.parse_args() check_model_doc(args.fix_and_overwrite)
361
"""simple docstring""" from collections import defaultdict def _A (__a , __a ) -> bool: """simple docstring""" SCREAMING_SNAKE_CASE_ : Dict = first_str.lower().strip() SCREAMING_SNAKE_CASE_ : List[Any] = second_str.lower().strip() # Remove whitespace SCREAMING_SNAKE_CASE_ : Dict = first_str.replace(''' ''' , '''''' ) SCREAMING_SNAKE_CASE_ : Optional[Any] = second_str.replace(''' ''' , '''''' ) # Strings of different lengths are not anagrams if len(__a ) != len(__a ): return False # Default values for count should be 0 SCREAMING_SNAKE_CASE_ : defaultdict[str, int] = defaultdict(__a ) # For each character in input strings, # increment count in the corresponding for i in range(len(__a ) ): count[first_str[i]] += 1 count[second_str[i]] -= 1 return all(_count == 0 for _count in count.values() ) if __name__ == "__main__": from doctest import testmod testmod() UpperCAmelCase_ : Any = input("""Enter the first string """).strip() UpperCAmelCase_ : Optional[int] = input("""Enter the second string """).strip() UpperCAmelCase_ : Union[str, Any] = check_anagrams(input_a, input_b) print(f'''{input_a} and {input_b} are {'' if status else 'not '}anagrams.''')
318
0
"""simple docstring""" from dataclasses import dataclass from typing import Dict, Optional, Union import torch import torch.nn.functional as F from torch import nn from ..configuration_utils import ConfigMixin, register_to_config from ..utils import BaseOutput from .attention import BasicTransformerBlock from .attention_processor import AttentionProcessor, AttnProcessor from .embeddings import TimestepEmbedding, Timesteps from .modeling_utils import ModelMixin @dataclass class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = 4_2 class lowerCAmelCase__ ( UpperCAmelCase__ , UpperCAmelCase__ ): '''simple docstring''' @register_to_config def __init__( self : str , lowercase_ : int = 32 , lowercase_ : int = 64 , lowercase_ : int = 20 , lowercase_ : int = 768 , lowercase_ : Any=77 , lowercase_ : Optional[int]=4 , lowercase_ : float = 0.0 , lowercase_ : str = "silu" , lowercase_ : Optional[str] = None , lowercase_ : Optional[str] = None , lowercase_ : Optional[str] = "linear" , lowercase_ : Optional[str] = "prd" , lowercase_ : Optional[int] = None , lowercase_ : Optional[int] = None , lowercase_ : Optional[int] = None , ): '''simple docstring''' super().__init__() SCREAMING_SNAKE_CASE_ : List[str] = num_attention_heads SCREAMING_SNAKE_CASE_ : Union[str, Any] = attention_head_dim SCREAMING_SNAKE_CASE_ : Union[str, Any] = num_attention_heads * attention_head_dim SCREAMING_SNAKE_CASE_ : Union[str, Any] = additional_embeddings SCREAMING_SNAKE_CASE_ : List[Any] = time_embed_dim or inner_dim SCREAMING_SNAKE_CASE_ : Dict = embedding_proj_dim or embedding_dim SCREAMING_SNAKE_CASE_ : Any = clip_embed_dim or embedding_dim SCREAMING_SNAKE_CASE_ : Any = Timesteps(lowercase_ , lowercase_ , 0) SCREAMING_SNAKE_CASE_ : List[str] = TimestepEmbedding(lowercase_ , lowercase_ , out_dim=lowercase_ , act_fn=lowercase_) SCREAMING_SNAKE_CASE_ : Any = nn.Linear(lowercase_ , lowercase_) if embedding_proj_norm_type is None: SCREAMING_SNAKE_CASE_ : Union[str, Any] = None elif embedding_proj_norm_type == "layer": SCREAMING_SNAKE_CASE_ : int = nn.LayerNorm(lowercase_) else: raise ValueError(F'unsupported embedding_proj_norm_type: {embedding_proj_norm_type}') SCREAMING_SNAKE_CASE_ : List[Any] = nn.Linear(lowercase_ , lowercase_) if encoder_hid_proj_type is None: SCREAMING_SNAKE_CASE_ : List[str] = None elif encoder_hid_proj_type == "linear": SCREAMING_SNAKE_CASE_ : Union[str, Any] = nn.Linear(lowercase_ , lowercase_) else: raise ValueError(F'unsupported encoder_hid_proj_type: {encoder_hid_proj_type}') SCREAMING_SNAKE_CASE_ : Tuple = nn.Parameter(torch.zeros(1 , num_embeddings + additional_embeddings , lowercase_)) if added_emb_type == "prd": SCREAMING_SNAKE_CASE_ : str = nn.Parameter(torch.zeros(1 , 1 , lowercase_)) elif added_emb_type is None: SCREAMING_SNAKE_CASE_ : Union[str, Any] = None else: raise ValueError( F'`added_emb_type`: {added_emb_type} is not supported. Make sure to choose one of `\'prd\'` or `None`.') SCREAMING_SNAKE_CASE_ : List[str] = nn.ModuleList( [ BasicTransformerBlock( lowercase_ , lowercase_ , lowercase_ , dropout=lowercase_ , activation_fn='''gelu''' , attention_bias=lowercase_ , ) for d in range(lowercase_) ]) if norm_in_type == "layer": SCREAMING_SNAKE_CASE_ : Union[str, Any] = nn.LayerNorm(lowercase_) elif norm_in_type is None: SCREAMING_SNAKE_CASE_ : Union[str, Any] = None else: raise ValueError(F'Unsupported norm_in_type: {norm_in_type}.') SCREAMING_SNAKE_CASE_ : List[str] = nn.LayerNorm(lowercase_) SCREAMING_SNAKE_CASE_ : str = nn.Linear(lowercase_ , lowercase_) SCREAMING_SNAKE_CASE_ : Tuple = torch.full( [num_embeddings + additional_embeddings, num_embeddings + additional_embeddings] , -10000.0) causal_attention_mask.triu_(1) SCREAMING_SNAKE_CASE_ : Union[str, Any] = causal_attention_mask[None, ...] self.register_buffer('''causal_attention_mask''' , lowercase_ , persistent=lowercase_) SCREAMING_SNAKE_CASE_ : int = nn.Parameter(torch.zeros(1 , lowercase_)) SCREAMING_SNAKE_CASE_ : str = nn.Parameter(torch.zeros(1 , lowercase_)) @property # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = {} def fn_recursive_add_processors(lowercase_ : str , lowercase_ : torch.nn.Module , lowercase_ : Dict[str, AttentionProcessor]): if hasattr(lowercase_ , '''set_processor'''): SCREAMING_SNAKE_CASE_ : str = module.processor for sub_name, child in module.named_children(): fn_recursive_add_processors(F'{name}.{sub_name}' , lowercase_ , lowercase_) return processors for name, module in self.named_children(): fn_recursive_add_processors(lowercase_ , lowercase_ , lowercase_) return processors def _SCREAMING_SNAKE_CASE ( self : List[str] , lowercase_ : Union[AttentionProcessor, Dict[str, AttentionProcessor]]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = len(self.attn_processors.keys()) if isinstance(lowercase_ , lowercase_) and len(lowercase_) != count: raise ValueError( F'A dict of processors was passed, but the number of processors {len(lowercase_)} does not match the' F' number of attention layers: {count}. Please make sure to pass {count} processor classes.') def fn_recursive_attn_processor(lowercase_ : str , lowercase_ : torch.nn.Module , lowercase_ : List[str]): if hasattr(lowercase_ , '''set_processor'''): if not isinstance(lowercase_ , lowercase_): module.set_processor(lowercase_) else: module.set_processor(processor.pop(F'{name}.processor')) for sub_name, child in module.named_children(): fn_recursive_attn_processor(F'{name}.{sub_name}' , lowercase_ , lowercase_) for name, module in self.named_children(): fn_recursive_attn_processor(lowercase_ , lowercase_ , lowercase_) def _SCREAMING_SNAKE_CASE ( self : Tuple): '''simple docstring''' self.set_attn_processor(AttnProcessor()) def _SCREAMING_SNAKE_CASE ( self : Tuple , lowercase_ : Optional[int] , lowercase_ : Union[torch.Tensor, float, int] , lowercase_ : torch.FloatTensor , lowercase_ : Optional[torch.FloatTensor] = None , lowercase_ : Optional[torch.BoolTensor] = None , lowercase_ : bool = True , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[str] = hidden_states.shape[0] SCREAMING_SNAKE_CASE_ : Dict = timestep if not torch.is_tensor(lowercase_): SCREAMING_SNAKE_CASE_ : List[Any] = torch.tensor([timesteps] , dtype=torch.long , device=hidden_states.device) elif torch.is_tensor(lowercase_) and len(timesteps.shape) == 0: SCREAMING_SNAKE_CASE_ : List[Any] = timesteps[None].to(hidden_states.device) # broadcast to batch dimension in a way that's compatible with ONNX/Core ML SCREAMING_SNAKE_CASE_ : List[Any] = timesteps * torch.ones(lowercase_ , dtype=timesteps.dtype , device=timesteps.device) SCREAMING_SNAKE_CASE_ : Optional[int] = self.time_proj(lowercase_) # timesteps does not contain any weights and will always return f32 tensors # but time_embedding might be fp16, so we need to cast here. SCREAMING_SNAKE_CASE_ : int = timesteps_projected.to(dtype=self.dtype) SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.time_embedding(lowercase_) if self.embedding_proj_norm is not None: SCREAMING_SNAKE_CASE_ : Optional[int] = self.embedding_proj_norm(lowercase_) SCREAMING_SNAKE_CASE_ : Any = self.embedding_proj(lowercase_) if self.encoder_hidden_states_proj is not None and encoder_hidden_states is not None: SCREAMING_SNAKE_CASE_ : int = self.encoder_hidden_states_proj(lowercase_) elif self.encoder_hidden_states_proj is not None and encoder_hidden_states is None: raise ValueError('''`encoder_hidden_states_proj` requires `encoder_hidden_states` to be set''') SCREAMING_SNAKE_CASE_ : str = self.proj_in(lowercase_) SCREAMING_SNAKE_CASE_ : int = self.positional_embedding.to(hidden_states.dtype) SCREAMING_SNAKE_CASE_ : Any = [] SCREAMING_SNAKE_CASE_ : List[Any] = 0 if encoder_hidden_states is not None: additional_embeds.append(lowercase_) additional_embeddings_len += encoder_hidden_states.shape[1] if len(proj_embeddings.shape) == 2: SCREAMING_SNAKE_CASE_ : Optional[Any] = proj_embeddings[:, None, :] if len(hidden_states.shape) == 2: SCREAMING_SNAKE_CASE_ : Union[str, Any] = hidden_states[:, None, :] SCREAMING_SNAKE_CASE_ : Dict = additional_embeds + [ proj_embeddings, time_embeddings[:, None, :], hidden_states, ] if self.prd_embedding is not None: SCREAMING_SNAKE_CASE_ : Optional[Any] = self.prd_embedding.to(hidden_states.dtype).expand(lowercase_ , -1 , -1) additional_embeds.append(lowercase_) SCREAMING_SNAKE_CASE_ : Any = torch.cat( lowercase_ , dim=1 , ) # Allow positional_embedding to not include the `addtional_embeddings` and instead pad it with zeros for these additional tokens SCREAMING_SNAKE_CASE_ : Dict = additional_embeddings_len + proj_embeddings.shape[1] + 1 if positional_embeddings.shape[1] < hidden_states.shape[1]: SCREAMING_SNAKE_CASE_ : Tuple = F.pad( lowercase_ , ( 0, 0, additional_embeddings_len, self.prd_embedding.shape[1] if self.prd_embedding is not None else 0, ) , value=0.0 , ) SCREAMING_SNAKE_CASE_ : Optional[int] = hidden_states + positional_embeddings if attention_mask is not None: SCREAMING_SNAKE_CASE_ : Any = (1 - attention_mask.to(hidden_states.dtype)) * -10000.0 SCREAMING_SNAKE_CASE_ : Tuple = F.pad(lowercase_ , (0, self.additional_embeddings) , value=0.0) SCREAMING_SNAKE_CASE_ : Optional[Any] = (attention_mask[:, None, :] + self.causal_attention_mask).to(hidden_states.dtype) SCREAMING_SNAKE_CASE_ : Union[str, Any] = attention_mask.repeat_interleave(self.config.num_attention_heads , dim=0) if self.norm_in is not None: SCREAMING_SNAKE_CASE_ : List[Any] = self.norm_in(lowercase_) for block in self.transformer_blocks: SCREAMING_SNAKE_CASE_ : Optional[int] = block(lowercase_ , attention_mask=lowercase_) SCREAMING_SNAKE_CASE_ : Any = self.norm_out(lowercase_) if self.prd_embedding is not None: SCREAMING_SNAKE_CASE_ : Tuple = hidden_states[:, -1] else: SCREAMING_SNAKE_CASE_ : Optional[Any] = hidden_states[:, additional_embeddings_len:] SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.proj_to_clip_embeddings(lowercase_) if not return_dict: return (predicted_image_embedding,) return PriorTransformerOutput(predicted_image_embedding=lowercase_) def _SCREAMING_SNAKE_CASE ( self : int , lowercase_ : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = (prior_latents * self.clip_std) + self.clip_mean return prior_latents
362
"""simple docstring""" import argparse from collections import defaultdict import yaml UpperCAmelCase_ : Optional[Any] = """docs/source/en/_toctree.yml""" def _A (__a ) -> Union[str, Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : str = defaultdict(__a ) for doc in model_doc: counts[doc["local"]] += 1 SCREAMING_SNAKE_CASE_ : List[Any] = [key for key, value in counts.items() if value > 1] SCREAMING_SNAKE_CASE_ : int = [] for duplicate_key in duplicates: SCREAMING_SNAKE_CASE_ : List[str] = list({doc['''title'''] for doc in model_doc if doc['''local'''] == duplicate_key} ) if len(__a ) > 1: raise ValueError( f'{duplicate_key} is present several times in the documentation table of content at ' '''`docs/source/en/_toctree.yml` with different *Title* values. Choose one of those and remove the ''' '''others.''' ) # Only add this once new_doc.append({'''local''': duplicate_key, '''title''': titles[0]} ) # Add none duplicate-keys new_doc.extend([doc for doc in model_doc if counts[doc['''local''']] == 1] ) # Sort return sorted(__a , key=lambda __a : s["title"].lower() ) def _A (__a=False ) -> Tuple: """simple docstring""" with open(__a , encoding='''utf-8''' ) as f: SCREAMING_SNAKE_CASE_ : Dict = yaml.safe_load(f.read() ) # Get to the API doc SCREAMING_SNAKE_CASE_ : Any = 0 while content[api_idx]["title"] != "API": api_idx += 1 SCREAMING_SNAKE_CASE_ : str = content[api_idx]['''sections'''] # Then to the model doc SCREAMING_SNAKE_CASE_ : List[Any] = 0 while api_doc[model_idx]["title"] != "Models": model_idx += 1 SCREAMING_SNAKE_CASE_ : Optional[int] = api_doc[model_idx]['''sections'''] SCREAMING_SNAKE_CASE_ : str = [(idx, section) for idx, section in enumerate(__a ) if '''sections''' in section] SCREAMING_SNAKE_CASE_ : Optional[Any] = False for idx, modality_doc in modalities_docs: SCREAMING_SNAKE_CASE_ : List[str] = modality_doc['''sections'''] SCREAMING_SNAKE_CASE_ : Union[str, Any] = clean_model_doc_toc(__a ) if old_modality_doc != new_modality_doc: SCREAMING_SNAKE_CASE_ : str = True if overwrite: SCREAMING_SNAKE_CASE_ : Optional[int] = new_modality_doc if diff: if overwrite: SCREAMING_SNAKE_CASE_ : List[Any] = model_doc SCREAMING_SNAKE_CASE_ : int = api_doc with open(__a , '''w''' , encoding='''utf-8''' ) as f: f.write(yaml.dump(__a , allow_unicode=__a ) ) else: raise ValueError( '''The model doc part of the table of content is not properly sorted, run `make style` to fix this.''' ) if __name__ == "__main__": UpperCAmelCase_ : List[str] = argparse.ArgumentParser() parser.add_argument("""--fix_and_overwrite""", action="""store_true""", help="""Whether to fix inconsistencies.""") UpperCAmelCase_ : Tuple = parser.parse_args() check_model_doc(args.fix_and_overwrite)
318
0
"""simple docstring""" import unittest from parameterized import parameterized from transformers import LlamaConfig, is_torch_available, set_seed from transformers.testing_utils import require_torch, slow, torch_device from ...generation.test_utils import GenerationTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaTokenizer class lowerCAmelCase__ : '''simple docstring''' def __init__( self : Union[str, Any] , lowercase_ : int , lowercase_ : List[Any]=13 , lowercase_ : List[Any]=7 , lowercase_ : Tuple=True , lowercase_ : str=True , lowercase_ : List[str]=False , lowercase_ : int=True , lowercase_ : Dict=99 , lowercase_ : str=32 , lowercase_ : Any=5 , lowercase_ : str=4 , lowercase_ : Optional[Any]=37 , lowercase_ : Optional[int]="gelu" , lowercase_ : Any=0.1 , lowercase_ : Union[str, Any]=0.1 , lowercase_ : Optional[int]=512 , lowercase_ : List[str]=16 , lowercase_ : Optional[int]=2 , lowercase_ : Union[str, Any]=0.02 , lowercase_ : str=3 , lowercase_ : Dict=4 , lowercase_ : Optional[Any]=None , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = parent SCREAMING_SNAKE_CASE_ : List[str] = batch_size SCREAMING_SNAKE_CASE_ : str = seq_length SCREAMING_SNAKE_CASE_ : Dict = is_training SCREAMING_SNAKE_CASE_ : str = use_input_mask SCREAMING_SNAKE_CASE_ : Optional[int] = use_token_type_ids SCREAMING_SNAKE_CASE_ : Any = use_labels SCREAMING_SNAKE_CASE_ : Optional[Any] = vocab_size SCREAMING_SNAKE_CASE_ : Optional[int] = hidden_size SCREAMING_SNAKE_CASE_ : Union[str, Any] = num_hidden_layers SCREAMING_SNAKE_CASE_ : Union[str, Any] = num_attention_heads SCREAMING_SNAKE_CASE_ : Dict = intermediate_size SCREAMING_SNAKE_CASE_ : Any = hidden_act SCREAMING_SNAKE_CASE_ : int = hidden_dropout_prob SCREAMING_SNAKE_CASE_ : List[str] = attention_probs_dropout_prob SCREAMING_SNAKE_CASE_ : List[str] = max_position_embeddings SCREAMING_SNAKE_CASE_ : Optional[Any] = type_vocab_size SCREAMING_SNAKE_CASE_ : Dict = type_sequence_label_size SCREAMING_SNAKE_CASE_ : Tuple = initializer_range SCREAMING_SNAKE_CASE_ : Optional[int] = num_labels SCREAMING_SNAKE_CASE_ : str = num_choices SCREAMING_SNAKE_CASE_ : int = scope def _SCREAMING_SNAKE_CASE ( self : Any): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size) SCREAMING_SNAKE_CASE_ : Tuple = None if self.use_input_mask: SCREAMING_SNAKE_CASE_ : Tuple = random_attention_mask([self.batch_size, self.seq_length]) SCREAMING_SNAKE_CASE_ : int = None if self.use_token_type_ids: SCREAMING_SNAKE_CASE_ : Union[str, Any] = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size) SCREAMING_SNAKE_CASE_ : int = None SCREAMING_SNAKE_CASE_ : str = None SCREAMING_SNAKE_CASE_ : List[str] = None if self.use_labels: SCREAMING_SNAKE_CASE_ : List[Any] = ids_tensor([self.batch_size] , self.type_sequence_label_size) SCREAMING_SNAKE_CASE_ : Tuple = ids_tensor([self.batch_size, self.seq_length] , self.num_labels) SCREAMING_SNAKE_CASE_ : List[Any] = ids_tensor([self.batch_size] , self.num_choices) SCREAMING_SNAKE_CASE_ : Tuple = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' return LlamaConfig( 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=lowercase_ , initializer_range=self.initializer_range , ) def _SCREAMING_SNAKE_CASE ( self : Union[str, Any] , lowercase_ : Optional[int] , lowercase_ : Optional[int] , lowercase_ : Any , lowercase_ : Optional[int] , lowercase_ : Tuple , lowercase_ : Any , lowercase_ : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = LlamaModel(config=lowercase_) model.to(lowercase_) model.eval() SCREAMING_SNAKE_CASE_ : str = model(lowercase_ , attention_mask=lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = model(lowercase_) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size)) def _SCREAMING_SNAKE_CASE ( self : Any , lowercase_ : int , lowercase_ : List[str] , lowercase_ : int , lowercase_ : Any , lowercase_ : str , lowercase_ : Any , lowercase_ : int , lowercase_ : List[Any] , lowercase_ : List[str] , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = True SCREAMING_SNAKE_CASE_ : Any = LlamaModel(lowercase_) model.to(lowercase_) model.eval() SCREAMING_SNAKE_CASE_ : List[Any] = model( lowercase_ , attention_mask=lowercase_ , encoder_hidden_states=lowercase_ , encoder_attention_mask=lowercase_ , ) SCREAMING_SNAKE_CASE_ : Optional[int] = model( lowercase_ , attention_mask=lowercase_ , encoder_hidden_states=lowercase_ , ) SCREAMING_SNAKE_CASE_ : List[Any] = model(lowercase_ , attention_mask=lowercase_) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size)) def _SCREAMING_SNAKE_CASE ( self : List[str] , lowercase_ : Any , lowercase_ : List[str] , lowercase_ : List[Any] , lowercase_ : List[str] , lowercase_ : int , lowercase_ : Dict , lowercase_ : Optional[int] , lowercase_ : Optional[int] , lowercase_ : Optional[Any] , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = LlamaForCausalLM(config=lowercase_) model.to(lowercase_) model.eval() SCREAMING_SNAKE_CASE_ : Any = model(lowercase_ , attention_mask=lowercase_ , labels=lowercase_) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size)) def _SCREAMING_SNAKE_CASE ( self : Any , lowercase_ : Any , lowercase_ : str , lowercase_ : Optional[Any] , lowercase_ : str , lowercase_ : Dict , lowercase_ : Union[str, Any] , lowercase_ : Optional[int] , lowercase_ : Optional[int] , lowercase_ : str , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = True SCREAMING_SNAKE_CASE_ : Any = True SCREAMING_SNAKE_CASE_ : List[Any] = LlamaForCausalLM(config=lowercase_) model.to(lowercase_) model.eval() # first forward pass SCREAMING_SNAKE_CASE_ : Any = model( lowercase_ , attention_mask=lowercase_ , encoder_hidden_states=lowercase_ , encoder_attention_mask=lowercase_ , use_cache=lowercase_ , ) SCREAMING_SNAKE_CASE_ : Any = outputs.past_key_values # create hypothetical multiple next token and extent to next_input_ids SCREAMING_SNAKE_CASE_ : List[str] = ids_tensor((self.batch_size, 3) , config.vocab_size) SCREAMING_SNAKE_CASE_ : Union[str, Any] = ids_tensor((self.batch_size, 3) , vocab_size=2) # append to next input_ids and SCREAMING_SNAKE_CASE_ : List[str] = torch.cat([input_ids, next_tokens] , dim=-1) SCREAMING_SNAKE_CASE_ : List[Any] = torch.cat([input_mask, next_mask] , dim=-1) SCREAMING_SNAKE_CASE_ : Optional[Any] = model( lowercase_ , attention_mask=lowercase_ , encoder_hidden_states=lowercase_ , encoder_attention_mask=lowercase_ , output_hidden_states=lowercase_ , )['''hidden_states'''][0] SCREAMING_SNAKE_CASE_ : int = model( lowercase_ , attention_mask=lowercase_ , encoder_hidden_states=lowercase_ , encoder_attention_mask=lowercase_ , past_key_values=lowercase_ , output_hidden_states=lowercase_ , )['''hidden_states'''][0] # select random slice SCREAMING_SNAKE_CASE_ : Tuple = ids_tensor((1,) , output_from_past.shape[-1]).item() SCREAMING_SNAKE_CASE_ : Dict = output_from_no_past[:, -3:, random_slice_idx].detach() SCREAMING_SNAKE_CASE_ : Tuple = output_from_past[:, :, random_slice_idx].detach() self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]) # test that outputs are equal for slice self.parent.assertTrue(torch.allclose(lowercase_ , lowercase_ , atol=1e-3)) def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = self.prepare_config_and_inputs() ( SCREAMING_SNAKE_CASE_ ) : Union[str, Any] = config_and_inputs SCREAMING_SNAKE_CASE_ : Optional[int] = {'''input_ids''': input_ids, '''attention_mask''': input_mask} return config, inputs_dict @require_torch class lowerCAmelCase__ ( UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): '''simple docstring''' __UpperCamelCase = (LlamaModel, LlamaForCausalLM, LlamaForSequenceClassification) if is_torch_available() else () __UpperCamelCase = (LlamaForCausalLM,) if is_torch_available() else () __UpperCamelCase = ( { "feature-extraction": LlamaModel, "text-classification": LlamaForSequenceClassification, "text-generation": LlamaForCausalLM, "zero-shot": LlamaForSequenceClassification, } if is_torch_available() else {} ) __UpperCamelCase = False __UpperCamelCase = False def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = LlamaModelTester(self) SCREAMING_SNAKE_CASE_ : List[Any] = ConfigTester(self , config_class=lowercase_ , hidden_size=37) def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' self.config_tester.run_common_tests() def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*lowercase_) def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = self.model_tester.prepare_config_and_inputs() for type in ["absolute", "relative_key", "relative_key_query"]: SCREAMING_SNAKE_CASE_ : Optional[Any] = type self.model_tester.create_and_check_model(*lowercase_) def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[str] = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE_ : Tuple = 3 SCREAMING_SNAKE_CASE_ : List[Any] = input_dict['''input_ids'''] SCREAMING_SNAKE_CASE_ : Tuple = input_ids.ne(1).to(lowercase_) SCREAMING_SNAKE_CASE_ : str = ids_tensor([self.model_tester.batch_size] , self.model_tester.type_sequence_label_size) SCREAMING_SNAKE_CASE_ : Optional[int] = LlamaForSequenceClassification(lowercase_) model.to(lowercase_) model.eval() SCREAMING_SNAKE_CASE_ : Tuple = model(lowercase_ , attention_mask=lowercase_ , labels=lowercase_) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels)) def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE_ : Optional[Any] = 3 SCREAMING_SNAKE_CASE_ : Tuple = '''single_label_classification''' SCREAMING_SNAKE_CASE_ : List[str] = input_dict['''input_ids'''] SCREAMING_SNAKE_CASE_ : List[str] = input_ids.ne(1).to(lowercase_) SCREAMING_SNAKE_CASE_ : Union[str, Any] = ids_tensor([self.model_tester.batch_size] , self.model_tester.type_sequence_label_size) SCREAMING_SNAKE_CASE_ : str = LlamaForSequenceClassification(lowercase_) model.to(lowercase_) model.eval() SCREAMING_SNAKE_CASE_ : Dict = model(lowercase_ , attention_mask=lowercase_ , labels=lowercase_) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels)) def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE_ : Optional[Any] = 3 SCREAMING_SNAKE_CASE_ : Tuple = '''multi_label_classification''' SCREAMING_SNAKE_CASE_ : Optional[int] = input_dict['''input_ids'''] SCREAMING_SNAKE_CASE_ : List[str] = input_ids.ne(1).to(lowercase_) SCREAMING_SNAKE_CASE_ : List[Any] = ids_tensor( [self.model_tester.batch_size, config.num_labels] , self.model_tester.type_sequence_label_size).to(torch.float) SCREAMING_SNAKE_CASE_ : Optional[Any] = LlamaForSequenceClassification(lowercase_) model.to(lowercase_) model.eval() SCREAMING_SNAKE_CASE_ : Tuple = model(lowercase_ , attention_mask=lowercase_ , labels=lowercase_) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels)) @unittest.skip('''LLaMA buffers include complex numbers, which breaks this test''') def _SCREAMING_SNAKE_CASE ( self : Tuple): '''simple docstring''' pass @parameterized.expand([('''linear''',), ('''dynamic''',)]) def _SCREAMING_SNAKE_CASE ( self : Optional[int] , lowercase_ : Tuple): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE_ : int = ids_tensor([1, 10] , config.vocab_size) SCREAMING_SNAKE_CASE_ : str = ids_tensor([1, int(config.max_position_embeddings * 1.5)] , config.vocab_size) set_seed(42) # Fixed seed at init time so the two models get the same random weights SCREAMING_SNAKE_CASE_ : Tuple = LlamaModel(lowercase_) original_model.to(lowercase_) original_model.eval() SCREAMING_SNAKE_CASE_ : Optional[Any] = original_model(lowercase_).last_hidden_state SCREAMING_SNAKE_CASE_ : Union[str, Any] = original_model(lowercase_).last_hidden_state set_seed(42) # Fixed seed at init time so the two models get the same random weights SCREAMING_SNAKE_CASE_ : int = {'''type''': scaling_type, '''factor''': 10.0} SCREAMING_SNAKE_CASE_ : Tuple = LlamaModel(lowercase_) scaled_model.to(lowercase_) scaled_model.eval() SCREAMING_SNAKE_CASE_ : List[Any] = scaled_model(lowercase_).last_hidden_state SCREAMING_SNAKE_CASE_ : int = scaled_model(lowercase_).last_hidden_state # Dynamic scaling does not change the RoPE embeddings until it receives an input longer than the original # maximum sequence length, so the outputs for the short input should match. if scaling_type == "dynamic": self.assertTrue(torch.allclose(lowercase_ , lowercase_ , atol=1e-5)) else: self.assertFalse(torch.allclose(lowercase_ , lowercase_ , atol=1e-5)) # The output should be different for long inputs self.assertFalse(torch.allclose(lowercase_ , lowercase_ , atol=1e-5)) @require_torch class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' @unittest.skip('''Logits are not exactly the same, once we fix the instabalities somehow, will update!''') @slow def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = [1, 306, 4658, 278, 6593, 310, 2834, 338] SCREAMING_SNAKE_CASE_ : List[Any] = LlamaForCausalLM.from_pretrained('''meta-llama/Llama-2-7b-hf''' , device_map='''auto''') SCREAMING_SNAKE_CASE_ : Union[str, Any] = model(torch.tensor([input_ids])) # Expected mean on dim = -1 SCREAMING_SNAKE_CASE_ : Dict = torch.tensor([[-6.65_50, -4.12_27, -4.98_59, -3.24_06, 0.82_62, -3.00_33, 1.29_64, -3.36_99]]) torch.testing.assert_close(out.mean(-1) , lowercase_ , atol=1e-2 , rtol=1e-2) # slicing logits[0, 0, 0:30] # fmt: off SCREAMING_SNAKE_CASE_ : int = torch.tensor([-12.82_81, -7.44_53, -0.46_39, -8.06_25, -7.25_00, -8.00_00, -6.48_83, -7.76_95, -7.84_38, -7.03_12, -6.21_88, -7.13_28, -1.84_96, 1.99_61, -8.62_50, -6.72_27, -12.82_81, -6.94_92, -7.07_42, -7.78_52, -7.58_20, -7.90_62, -6.93_75, -7.98_05, -8.34_38, -8.15_62, -8.04_69, -7.62_50, -7.74_22, -7.33_98,]) # fmt: on torch.testing.assert_close(out[0, 0, :30] , lowercase_ , atol=1e-5 , rtol=1e-5) @unittest.skip('''Logits are not exactly the same, once we fix the instabalities somehow, will update!''') @slow def _SCREAMING_SNAKE_CASE ( self : Tuple): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = [1, 306, 4658, 278, 6593, 310, 2834, 338] SCREAMING_SNAKE_CASE_ : Union[str, Any] = LlamaForCausalLM.from_pretrained('''meta-llama/Llama-2-13b-hf''' , device_map='''auto''') SCREAMING_SNAKE_CASE_ : Tuple = model(torch.tensor(lowercase_)) # Expected mean on dim = -1 SCREAMING_SNAKE_CASE_ : Union[str, Any] = torch.tensor([[-2.06_22, -1.27_94, -1.16_38, -0.97_88, -1.46_03, -1.02_38, -1.78_93, -1.44_11]]) torch.testing.assert_close(out.mean(-1) , lowercase_ , atol=1e-2 , rtol=1e-2) # slicing logits[0, 0, 0:30] # fmt: off SCREAMING_SNAKE_CASE_ : Optional[int] = torch.tensor([-8.14_06, -8.05_47, 2.74_61, -1.23_44, -0.14_48, -1.82_62, -1.00_20, -1.81_54, -1.68_95, -1.85_16, -2.35_74, -0.92_77, 3.75_98, 6.57_42, -1.29_98, -0.11_77, -8.14_06, -2.96_88, -2.91_99, -3.16_99, -3.52_54, -2.35_55, -2.79_88, -3.41_41, -2.82_62, -4.51_95, -3.33_79, -3.31_64, -2.78_32, -3.02_73]) # fmt: on torch.testing.assert_close(out[0, 0, :30] , lowercase_ , atol=1e-5 , rtol=1e-5) @unittest.skip('''Logits are not exactly the same, once we fix the instabalities somehow, will update!''') @slow def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = [1, 306, 4658, 278, 6593, 310, 2834, 338] SCREAMING_SNAKE_CASE_ : Tuple = LlamaForCausalLM.from_pretrained('''meta-llama/Llama-2-13b-chat-hf''' , device_map='''auto''') SCREAMING_SNAKE_CASE_ : Optional[Any] = model(torch.tensor(lowercase_)) # Expected mean on dim = -1 SCREAMING_SNAKE_CASE_ : Any = torch.tensor([[-0.85_62, -1.85_20, -0.75_51, -0.41_62, -1.51_61, -1.20_38, -2.48_23, -2.32_54]]) torch.testing.assert_close(out.mean(-1) , lowercase_ , atol=1e-2 , rtol=1e-2) # slicing logits[0, 0, 0:30] # fmt: off SCREAMING_SNAKE_CASE_ : Dict = torch.tensor([-2.22_27, 4.88_28, 0.90_23, -0.45_78, -0.78_71, -0.10_33, -0.62_21, -0.57_86, -0.78_03, -1.06_74, -1.29_20, -0.15_70, 0.80_08, 2.07_23, -0.94_97, 0.27_71, -2.22_27, -0.76_12, -1.43_46, -1.20_61, -1.64_26, -0.30_00, -0.71_39, -1.19_34, -1.86_91, -1.69_73, -1.59_47, -1.27_05, -0.35_23, -0.55_13]) # fmt: on torch.testing.assert_close(out.mean(-1) , lowercase_ , atol=1e-2 , rtol=1e-2) @unittest.skip( '''Logits are not exactly the same, once we fix the instabalities somehow, will update! Also it is gonna be a `too_slow` test''') @slow def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = [1, 306, 4658, 278, 6593, 310, 2834, 338] SCREAMING_SNAKE_CASE_ : List[str] = LlamaForCausalLM.from_pretrained('''meta-llama/Llama-2-70b-hf''' , device_map='''auto''') SCREAMING_SNAKE_CASE_ : List[Any] = model(torch.tensor(lowercase_)) SCREAMING_SNAKE_CASE_ : List[Any] = torch.tensor( [[-4.23_27, -3.33_60, -4.66_65, -4.76_31, -1.81_80, -3.41_70, -1.42_11, -3.18_10]] , dtype=torch.floataa) torch.testing.assert_close(out.mean(-1) , lowercase_ , atol=1e-2 , rtol=1e-2) # fmt: off SCREAMING_SNAKE_CASE_ : List[str] = torch.tensor([-9.49_22, -3.95_51, 1.79_98, -5.67_58, -5.10_55, -5.89_84, -4.83_20, -6.80_86, -6.53_91, -5.61_72, -5.58_20, -5.53_52, 1.78_81, 3.62_89, -6.51_17, -3.47_85, -9.50_00, -6.03_52, -6.81_25, -6.01_95, -6.68_36, -5.47_27, -6.28_12, -6.03_91, -7.33_98, -7.42_97, -7.48_44, -6.58_20, -5.87_89, -5.53_12]) # fmt: on torch.testing.assert_close(out[0, 0, :30] , lowercase_ , atol=1e-5 , rtol=1e-5) @unittest.skip('''Model is curently gated''') @slow def _SCREAMING_SNAKE_CASE ( self : Any): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = '''Simply put, the theory of relativity states that 1) the laws of physics are the same everywhere in the universe and 2) the passage of time and the length of objects can vary depending on the observer\'s frame of reference.\n\nThe first part of the theory, that the laws of physics are the same everywhere, is known as the "princi''' SCREAMING_SNAKE_CASE_ : Any = '''Simply put, the theory of relativity states that ''' SCREAMING_SNAKE_CASE_ : Any = LlamaTokenizer.from_pretrained('''meta-llama/Llama-2-13b-chat-hf''') SCREAMING_SNAKE_CASE_ : str = tokenizer.encode(lowercase_ , return_tensors='''pt''') SCREAMING_SNAKE_CASE_ : Any = LlamaForCausalLM.from_pretrained( '''meta-llama/Llama-2-13b-chat-hf''' , device_map='''sequential''' , use_safetensors=lowercase_) # greedy generation outputs SCREAMING_SNAKE_CASE_ : Optional[int] = model.generate(lowercase_ , max_new_tokens=64 , top_p=lowercase_ , temperature=1 , do_sample=lowercase_) SCREAMING_SNAKE_CASE_ : int = tokenizer.decode(generated_ids[0] , skip_special_tokens=lowercase_) self.assertEqual(lowercase_ , lowercase_)
363
"""simple docstring""" from ...utils import ( OptionalDependencyNotAvailable, is_torch_available, is_transformers_available, is_transformers_version, ) try: if not (is_transformers_available() and is_torch_available() and is_transformers_version(""">=""", """4.25.0""")): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ...utils.dummy_torch_and_transformers_objects import ( VersatileDiffusionDualGuidedPipeline, VersatileDiffusionImageVariationPipeline, VersatileDiffusionPipeline, VersatileDiffusionTextToImagePipeline, ) else: from .modeling_text_unet import UNetFlatConditionModel from .pipeline_versatile_diffusion import VersatileDiffusionPipeline from .pipeline_versatile_diffusion_dual_guided import VersatileDiffusionDualGuidedPipeline from .pipeline_versatile_diffusion_image_variation import VersatileDiffusionImageVariationPipeline from .pipeline_versatile_diffusion_text_to_image import VersatileDiffusionTextToImagePipeline
318
0
"""simple docstring""" from __future__ import annotations def _A (__a , __a ) -> bool: """simple docstring""" SCREAMING_SNAKE_CASE_ : Dict = get_failure_array(__a ) # 2) Step through text searching for pattern SCREAMING_SNAKE_CASE_ : int = 0, 0 # index into text, pattern while i < len(__a ): if pattern[j] == text[i]: if j == (len(__a ) - 1): return True j += 1 # if this is a prefix in our pattern # just go back far enough to continue elif j > 0: SCREAMING_SNAKE_CASE_ : Optional[int] = failure[j - 1] continue i += 1 return False def _A (__a ) -> list[int]: """simple docstring""" SCREAMING_SNAKE_CASE_ : int = [0] SCREAMING_SNAKE_CASE_ : Tuple = 0 SCREAMING_SNAKE_CASE_ : Dict = 1 while j < len(__a ): if pattern[i] == pattern[j]: i += 1 elif i > 0: SCREAMING_SNAKE_CASE_ : Tuple = failure[i - 1] continue j += 1 failure.append(__a ) return failure if __name__ == "__main__": # Test 1) UpperCAmelCase_ : Any = """abc1abc12""" UpperCAmelCase_ : List[Any] = """alskfjaldsabc1abc1abc12k23adsfabcabc""" UpperCAmelCase_ : Union[str, Any] = """alskfjaldsk23adsfabcabc""" assert kmp(pattern, texta) and not kmp(pattern, texta) # Test 2) UpperCAmelCase_ : Optional[Any] = """ABABX""" UpperCAmelCase_ : List[Any] = """ABABZABABYABABX""" assert kmp(pattern, text) # Test 3) UpperCAmelCase_ : Tuple = """AAAB""" UpperCAmelCase_ : Optional[Any] = """ABAAAAAB""" assert kmp(pattern, text) # Test 4) UpperCAmelCase_ : Dict = """abcdabcy""" UpperCAmelCase_ : Dict = """abcxabcdabxabcdabcdabcy""" assert kmp(pattern, text) # Test 5) UpperCAmelCase_ : Any = """aabaabaaa""" assert get_failure_array(pattern) == [0, 1, 0, 1, 2, 3, 4, 5, 2]
364
"""simple docstring""" from __future__ import annotations UpperCAmelCase_ : List[str] = list[list[int]] # assigning initial values to the grid UpperCAmelCase_ : Matrix = [ [3, 0, 6, 5, 0, 8, 4, 0, 0], [5, 2, 0, 0, 0, 0, 0, 0, 0], [0, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] # a grid with no solution UpperCAmelCase_ : Matrix = [ [5, 0, 6, 5, 0, 8, 4, 0, 3], [5, 2, 0, 0, 0, 0, 0, 0, 2], [1, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] def _A (__a , __a , __a , __a ) -> bool: """simple docstring""" for i in range(9 ): if grid[row][i] == n or grid[i][column] == n: return False for i in range(3 ): for j in range(3 ): if grid[(row - row % 3) + i][(column - column % 3) + j] == n: return False return True def _A (__a ) -> tuple[int, int] | None: """simple docstring""" for i in range(9 ): for j in range(9 ): if grid[i][j] == 0: return i, j return None def _A (__a ) -> Matrix | None: """simple docstring""" if location := find_empty_location(__a ): SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Dict = location else: # If the location is ``None``, then the grid is solved. return grid for digit in range(1 , 10 ): if is_safe(__a , __a , __a , __a ): SCREAMING_SNAKE_CASE_ : Tuple = digit if sudoku(__a ) is not None: return grid SCREAMING_SNAKE_CASE_ : Any = 0 return None def _A (__a ) -> None: """simple docstring""" for row in grid: for cell in row: print(__a , end=''' ''' ) print() if __name__ == "__main__": # make a copy of grid so that you can compare with the unmodified grid for example_grid in (initial_grid, no_solution): print("""\nExample grid:\n""" + """=""" * 20) print_solution(example_grid) print("""\nExample grid solution:""") UpperCAmelCase_ : str = sudoku(example_grid) if solution is not None: print_solution(solution) else: print("""Cannot find a solution.""")
318
0
"""simple docstring""" import argparse import json import os import evaluate import torch from datasets import load_dataset from torch.optim import AdamW from torch.utils.data import DataLoader from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed from accelerate import Accelerator, DistributedType from accelerate.utils.deepspeed import DummyOptim, DummyScheduler UpperCAmelCase_ : Union[str, Any] = 16 UpperCAmelCase_ : Any = 32 def _A (__a , __a = 16 , __a = "bert-base-cased" ) -> Tuple: """simple docstring""" SCREAMING_SNAKE_CASE_ : List[str] = AutoTokenizer.from_pretrained(__a ) SCREAMING_SNAKE_CASE_ : List[str] = load_dataset('''glue''' , '''mrpc''' ) def tokenize_function(__a ): # max_length=None => use the model max length (it's actually the default) SCREAMING_SNAKE_CASE_ : str = tokenizer(examples['''sentence1'''] , examples['''sentence2'''] , truncation=__a , max_length=__a ) return outputs # Apply the method we just defined to all the examples in all the splits of the dataset SCREAMING_SNAKE_CASE_ : Tuple = datasets.map( __a , batched=__a , remove_columns=['''idx''', '''sentence1''', '''sentence2'''] , load_from_cache_file=__a ) # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the # transformers library SCREAMING_SNAKE_CASE_ : Union[str, Any] = tokenized_datasets.rename_column('''label''' , '''labels''' ) def collate_fn(__a ): # On TPU it's best to pad everything to the same length or training will be very slow. if accelerator.distributed_type == DistributedType.TPU: return tokenizer.pad(__a , padding='''max_length''' , max_length=1_28 , return_tensors='''pt''' ) return tokenizer.pad(__a , padding='''longest''' , return_tensors='''pt''' ) # Instantiate dataloaders. SCREAMING_SNAKE_CASE_ : int = DataLoader( tokenized_datasets['''train'''] , shuffle=__a , collate_fn=__a , batch_size=__a ) SCREAMING_SNAKE_CASE_ : Any = DataLoader( tokenized_datasets['''validation'''] , shuffle=__a , collate_fn=__a , batch_size=__a ) return train_dataloader, eval_dataloader def _A (__a , __a , __a , __a ) -> Optional[Any]: """simple docstring""" model.eval() SCREAMING_SNAKE_CASE_ : List[Any] = 0 for step, batch in enumerate(__a ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) with torch.no_grad(): SCREAMING_SNAKE_CASE_ : Optional[Any] = model(**__a ) SCREAMING_SNAKE_CASE_ : str = outputs.logits.argmax(dim=-1 ) # It is slightly faster to call this once, than multiple times SCREAMING_SNAKE_CASE_ : Optional[Any] = accelerator.gather( (predictions, batch['''labels''']) ) # If we are in a multiprocess environment, the last batch has duplicates if accelerator.use_distributed: if step == len(__a ) - 1: SCREAMING_SNAKE_CASE_ : List[str] = predictions[: len(eval_dataloader.dataset ) - samples_seen] SCREAMING_SNAKE_CASE_ : Optional[Any] = references[: len(eval_dataloader.dataset ) - samples_seen] else: samples_seen += references.shape[0] metric.add_batch( predictions=__a , references=__a , ) SCREAMING_SNAKE_CASE_ : List[Any] = metric.compute() return eval_metric["accuracy"] def _A (__a , __a ) -> Union[str, Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[int] = Accelerator() # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs SCREAMING_SNAKE_CASE_ : str = config['''lr'''] SCREAMING_SNAKE_CASE_ : int = int(config['''num_epochs'''] ) SCREAMING_SNAKE_CASE_ : Any = int(config['''seed'''] ) SCREAMING_SNAKE_CASE_ : str = int(config['''batch_size'''] ) SCREAMING_SNAKE_CASE_ : List[Any] = args.model_name_or_path set_seed(__a ) SCREAMING_SNAKE_CASE_ : Any = get_dataloaders(__a , __a , __a ) # Instantiate the model (we build the model here so that the seed also control new weights initialization) SCREAMING_SNAKE_CASE_ : Tuple = AutoModelForSequenceClassification.from_pretrained(__a , return_dict=__a ) # Instantiate optimizer SCREAMING_SNAKE_CASE_ : str = ( AdamW if accelerator.state.deepspeed_plugin is None or '''optimizer''' not in accelerator.state.deepspeed_plugin.deepspeed_config else DummyOptim ) SCREAMING_SNAKE_CASE_ : Optional[Any] = optimizer_cls(params=model.parameters() , lr=__a ) if accelerator.state.deepspeed_plugin is not None: SCREAMING_SNAKE_CASE_ : str = accelerator.state.deepspeed_plugin.deepspeed_config[ '''gradient_accumulation_steps''' ] else: SCREAMING_SNAKE_CASE_ : List[str] = 1 SCREAMING_SNAKE_CASE_ : List[str] = (len(__a ) * num_epochs) // gradient_accumulation_steps # Instantiate scheduler if ( accelerator.state.deepspeed_plugin is None or "scheduler" not in accelerator.state.deepspeed_plugin.deepspeed_config ): SCREAMING_SNAKE_CASE_ : Optional[int] = get_linear_schedule_with_warmup( optimizer=__a , num_warmup_steps=0 , num_training_steps=__a , ) else: SCREAMING_SNAKE_CASE_ : int = DummyScheduler(__a , total_num_steps=__a , warmup_num_steps=0 ) # Prepare everything # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the # prepare method. SCREAMING_SNAKE_CASE_ : Any = accelerator.prepare( __a , __a , __a , __a , __a ) # We need to keep track of how many total steps we have iterated over SCREAMING_SNAKE_CASE_ : Optional[int] = 0 # We also need to keep track of the stating epoch so files are named properly SCREAMING_SNAKE_CASE_ : List[Any] = 0 SCREAMING_SNAKE_CASE_ : int = evaluate.load('''glue''' , '''mrpc''' ) SCREAMING_SNAKE_CASE_ : Tuple = num_epochs if args.partial_train_epoch is not None: SCREAMING_SNAKE_CASE_ : Dict = args.partial_train_epoch if args.resume_from_checkpoint: accelerator.load_state(args.resume_from_checkpoint ) SCREAMING_SNAKE_CASE_ : Optional[int] = args.resume_from_checkpoint.split('''epoch_''' )[1] SCREAMING_SNAKE_CASE_ : int = '''''' for char in epoch_string: if char.isdigit(): state_epoch_num += char else: break SCREAMING_SNAKE_CASE_ : List[Any] = int(__a ) + 1 SCREAMING_SNAKE_CASE_ : int = evaluation_loop(__a , __a , __a , __a ) accelerator.print('''resumed checkpoint performance:''' , __a ) accelerator.print('''resumed checkpoint\'s scheduler\'s lr:''' , lr_scheduler.get_lr()[0] ) accelerator.print('''resumed optimizers\'s lr:''' , optimizer.param_groups[0]['''lr'''] ) with open(os.path.join(args.output_dir , f'state_{starting_epoch-1}.json' ) , '''r''' ) as f: SCREAMING_SNAKE_CASE_ : int = json.load(__a ) assert resumed_state["accuracy"] == accuracy, "Accuracy mismatch, loading from checkpoint failed" assert ( resumed_state["lr"] == lr_scheduler.get_lr()[0] ), "Scheduler learning rate mismatch, loading from checkpoint failed" assert ( resumed_state["optimizer_lr"] == optimizer.param_groups[0]["lr"] ), "Optimizer learning rate mismatch, loading from checkpoint failed" assert resumed_state["epoch"] == starting_epoch - 1, "Epoch mismatch, loading from checkpoint failed" return # Now we train the model SCREAMING_SNAKE_CASE_ : Dict = {} for epoch in range(__a , __a ): model.train() for step, batch in enumerate(__a ): SCREAMING_SNAKE_CASE_ : Tuple = model(**__a ) SCREAMING_SNAKE_CASE_ : Optional[Any] = outputs.loss SCREAMING_SNAKE_CASE_ : Dict = loss / gradient_accumulation_steps accelerator.backward(__a ) if step % gradient_accumulation_steps == 0: optimizer.step() lr_scheduler.step() optimizer.zero_grad() overall_step += 1 SCREAMING_SNAKE_CASE_ : Dict = f'epoch_{epoch}' SCREAMING_SNAKE_CASE_ : int = os.path.join(args.output_dir , __a ) accelerator.save_state(__a ) SCREAMING_SNAKE_CASE_ : Tuple = evaluation_loop(__a , __a , __a , __a ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = accuracy SCREAMING_SNAKE_CASE_ : Optional[Any] = lr_scheduler.get_lr()[0] SCREAMING_SNAKE_CASE_ : List[Any] = optimizer.param_groups[0]['''lr'''] SCREAMING_SNAKE_CASE_ : Optional[int] = epoch SCREAMING_SNAKE_CASE_ : Union[str, Any] = overall_step accelerator.print(f'epoch {epoch}:' , __a ) accelerator.wait_for_everyone() if accelerator.is_main_process: with open(os.path.join(args.output_dir , f'state_{epoch}.json' ) , '''w''' ) as f: json.dump(__a , __a ) def _A () -> Optional[Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Union[str, Any] = argparse.ArgumentParser(description='''Simple example of training script tracking peak GPU memory usage.''' ) parser.add_argument( '''--model_name_or_path''' , type=__a , default='''bert-base-cased''' , help='''Path to pretrained model or model identifier from huggingface.co/models.''' , required=__a , ) parser.add_argument( '''--output_dir''' , type=__a , default='''.''' , help='''Optional save directory where all checkpoint folders will be stored. Default is the current working directory.''' , ) parser.add_argument( '''--resume_from_checkpoint''' , type=__a , default=__a , help='''If the training should continue from a checkpoint folder.''' , ) parser.add_argument( '''--partial_train_epoch''' , type=__a , default=__a , help='''If passed, the training will stop after this number of epochs.''' , ) parser.add_argument( '''--num_epochs''' , type=__a , default=2 , help='''Number of train epochs.''' , ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = parser.parse_args() SCREAMING_SNAKE_CASE_ : str = {'''lr''': 2e-5, '''num_epochs''': args.num_epochs, '''seed''': 42, '''batch_size''': 16} training_function(__a , __a ) if __name__ == "__main__": main()
365
"""simple docstring""" from itertools import permutations def _A (__a ) -> bool: """simple docstring""" if num[3] % 2 != 0: return False if (num[2] + num[3] + num[4]) % 3 != 0: return False if num[5] % 5 != 0: return False SCREAMING_SNAKE_CASE_ : List[str] = [7, 11, 13, 17] for i, test in enumerate(__a ): if (num[i + 4] * 1_00 + num[i + 5] * 10 + num[i + 6]) % test != 0: return False return True def _A (__a = 10 ) -> int: """simple docstring""" return sum( int(''''''.join(map(__a , __a ) ) ) for num in permutations(range(__a ) ) if is_substring_divisible(__a ) ) if __name__ == "__main__": print(f'''{solution() = }''')
318
0
"""simple docstring""" UpperCAmelCase_ : Optional[int] = 8.3_1_4_4_5_9_8 def _A (__a , __a ): """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 UpperCAmelCase_ : str = 300 UpperCAmelCase_ : str = 28 UpperCAmelCase_ : Any = rms_speed_of_molecule(temperature, molar_mass) print(f'''Vrms of Nitrogen gas at 300 K is {vrms} m/s''')
366
"""simple docstring""" UpperCAmelCase_ : List[Any] = 9.8_0_6_6_5 def _A (__a , __a , __a = g ) -> float: """simple docstring""" if fluid_density <= 0: raise ValueError('''Impossible fluid density''' ) if volume < 0: raise ValueError('''Impossible Object volume''' ) if gravity <= 0: raise ValueError('''Impossible Gravity''' ) return fluid_density * gravity * volume if __name__ == "__main__": import doctest # run doctest doctest.testmod()
318
0
"""simple docstring""" from typing import List, Optional, Union import numpy as np import tensorflow as tf from .utils import logging UpperCAmelCase_ : List[str] = logging.get_logger(__name__) def _A (__a ) -> List[int]: """simple docstring""" if isinstance(__a , np.ndarray ): return list(tensor.shape ) SCREAMING_SNAKE_CASE_ : str = tf.shape(__a ) if tensor.shape == tf.TensorShape(__a ): return dynamic SCREAMING_SNAKE_CASE_ : Tuple = tensor.shape.as_list() return [dynamic[i] if s is None else s for i, s in enumerate(__a )] def _A (__a , __a = None , __a = None ) -> tf.Tensor: """simple docstring""" return tf.nn.softmax(logits=logits + 1e-9 , axis=__a , name=__a ) def _A (__a , __a , __a , __a=1e-5 , __a=-1 ) -> str: """simple docstring""" if weight.shape.rank != 1 or bias.shape.rank != 1 or not isinstance(__a , __a ): raise NotImplementedError('''Only 1D weight and bias tensors are supported for now, with only a single axis.''' ) # Get mean and variance on the axis to be normalized SCREAMING_SNAKE_CASE_ : Tuple = tf.nn.moments(__a , axes=[axis] , keepdims=__a ) if axis != -1: # Reshape scale and weight to have the same rank as inputs, but with 1 dimensions # on every dimension except axis SCREAMING_SNAKE_CASE_ : str = [1] * inputs.shape.rank SCREAMING_SNAKE_CASE_ : str = shape_list(__a )[axis] SCREAMING_SNAKE_CASE_ : Dict = tf.reshape(__a , __a ) SCREAMING_SNAKE_CASE_ : str = tf.reshape(__a , __a ) # Compute layer normalization using the batch_normalization # function. SCREAMING_SNAKE_CASE_ : str = tf.nn.batch_normalization( __a , __a , __a , offset=__a , scale=__a , variance_epsilon=__a , ) return outputs def _A (__a , __a=0 , __a=-1 ) -> Tuple: """simple docstring""" if end_dim < 0: end_dim += input.shape.rank if start_dim < 0: start_dim += input.shape.rank if start_dim == end_dim: return input SCREAMING_SNAKE_CASE_ : Any = tf.shape(__a ) SCREAMING_SNAKE_CASE_ : str = tf.math.reduce_prod(in_shape[start_dim : end_dim + 1] ) SCREAMING_SNAKE_CASE_ : List[str] = tf.concat([in_shape[:start_dim], [flattened_dim], in_shape[end_dim + 1 :]] , axis=0 ) return tf.reshape(__a , __a ) def _A (__a ) -> tf.Tensor: """simple docstring""" if not isinstance(__a , tf.Tensor ): SCREAMING_SNAKE_CASE_ : List[Any] = tf.convert_to_tensor(__a ) # Catches stray NumPy inputs if encoder_attention_mask.shape.rank == 3: SCREAMING_SNAKE_CASE_ : List[str] = encoder_attention_mask[:, None, :, :] if encoder_attention_mask.shape.rank == 2: SCREAMING_SNAKE_CASE_ : List[Any] = encoder_attention_mask[:, None, None, :] # T5 has a mask that can compare sequence ids, we can simulate this here with this transposition # Cf. https://github.com/tensorflow/mesh/blob/8d2465e9bc93129b913b5ccc6a59aa97abd96ec6/mesh_tensorflow # /transformer/transformer_layers.py#L270 # encoder_extended_attention_mask = (encoder_extended_attention_mask == # encoder_extended_attention_mask.transpose(-1, -2)) SCREAMING_SNAKE_CASE_ : List[str] = ( tf.cast(1 , encoder_attention_mask.dtype ) - encoder_extended_attention_mask ) * encoder_extended_attention_mask.dtype.min return encoder_extended_attention_mask def _A (__a , __a , __a = "input_ids" ) -> None: """simple docstring""" tf.debugging.assert_less( __a , tf.cast(__a , dtype=tensor.dtype ) , message=( f'The maximum value of {tensor_name} ({tf.math.reduce_max(__a )}) must be smaller than the embedding ' f'layer\'s input dimension ({embed_dim}). The likely cause is some problem at tokenization time.' ) , ) def _A (__a , __a , __a ) -> Optional[Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[int] = 6_45_12 # Check that no item in `data` is larger than `HDF5_OBJECT_HEADER_LIMIT` # because in that case even chunking the array would not make the saving # possible. SCREAMING_SNAKE_CASE_ : List[str] = [x for x in data if len(__a ) > HDF5_OBJECT_HEADER_LIMIT] # Expecting this to never be true. if bad_attributes: raise RuntimeError( '''The following attributes cannot be saved to HDF5 file because ''' f'they are larger than {HDF5_OBJECT_HEADER_LIMIT} ' f'bytes: {bad_attributes}' ) SCREAMING_SNAKE_CASE_ : int = np.asarray(__a ) SCREAMING_SNAKE_CASE_ : List[Any] = 1 SCREAMING_SNAKE_CASE_ : Optional[Any] = np.array_split(__a , __a ) # This will never loop forever thanks to the test above. while any(x.nbytes > HDF5_OBJECT_HEADER_LIMIT for x in chunked_data ): num_chunks += 1 SCREAMING_SNAKE_CASE_ : Optional[int] = np.array_split(__a , __a ) if num_chunks > 1: for chunk_id, chunk_data in enumerate(__a ): SCREAMING_SNAKE_CASE_ : Any = chunk_data else: SCREAMING_SNAKE_CASE_ : List[str] = data def _A (__a , __a ) -> str: """simple docstring""" if name in group.attrs: SCREAMING_SNAKE_CASE_ : List[str] = [n.decode('''utf8''' ) if hasattr(__a , '''decode''' ) else n for n in group.attrs[name]] else: SCREAMING_SNAKE_CASE_ : Optional[int] = [] SCREAMING_SNAKE_CASE_ : Optional[Any] = 0 while "%s%d" % (name, chunk_id) in group.attrs: data.extend( [n.decode('''utf8''' ) if hasattr(__a , '''decode''' ) else n for n in group.attrs['''%s%d''' % (name, chunk_id)]] ) chunk_id += 1 return data def _A (__a ) -> List[str]: """simple docstring""" def _expand_single_ad_tensor(__a ): if isinstance(__a , tf.Tensor ) and t.shape.rank == 1: return tf.expand_dims(__a , axis=-1 ) return t return tf.nest.map_structure(_expand_single_ad_tensor , __a )
367
"""simple docstring""" # tests directory-specific settings - this file is run automatically # by pytest before any tests are run import sys import warnings from os.path import abspath, dirname, join # allow having multiple repository checkouts and not needing to remember to rerun # 'pip install -e .[dev]' when switching between checkouts and running tests. UpperCAmelCase_ : Union[str, Any] = abspath(join(dirname(dirname(dirname(__file__))), """src""")) sys.path.insert(1, git_repo_path) # silence FutureWarning warnings in tests since often we can't act on them until # they become normal warnings - i.e. the tests still need to test the current functionality warnings.simplefilter(action="""ignore""", category=FutureWarning) def _A (__a ) -> Union[str, Any]: """simple docstring""" from transformers.testing_utils import pytest_addoption_shared pytest_addoption_shared(__a ) def _A (__a ) -> Any: """simple docstring""" from transformers.testing_utils import pytest_terminal_summary_main SCREAMING_SNAKE_CASE_ : Optional[Any] = terminalreporter.config.getoption('''--make-reports''' ) if make_reports: pytest_terminal_summary_main(__a , id=__a )
318
0
"""simple docstring""" from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging UpperCAmelCase_ : List[str] = logging.get_logger(__name__) UpperCAmelCase_ : Dict = { """facebook/xmod-base""": """https://huggingface.co/facebook/xmod-base/resolve/main/config.json""", """facebook/xmod-large-prenorm""": """https://huggingface.co/facebook/xmod-large-prenorm/resolve/main/config.json""", """facebook/xmod-base-13-125k""": """https://huggingface.co/facebook/xmod-base-13-125k/resolve/main/config.json""", """facebook/xmod-base-30-125k""": """https://huggingface.co/facebook/xmod-base-30-125k/resolve/main/config.json""", """facebook/xmod-base-30-195k""": """https://huggingface.co/facebook/xmod-base-30-195k/resolve/main/config.json""", """facebook/xmod-base-60-125k""": """https://huggingface.co/facebook/xmod-base-60-125k/resolve/main/config.json""", """facebook/xmod-base-60-265k""": """https://huggingface.co/facebook/xmod-base-60-265k/resolve/main/config.json""", """facebook/xmod-base-75-125k""": """https://huggingface.co/facebook/xmod-base-75-125k/resolve/main/config.json""", """facebook/xmod-base-75-269k""": """https://huggingface.co/facebook/xmod-base-75-269k/resolve/main/config.json""", } class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = "xmod" def __init__( self : Tuple , lowercase_ : Any=30522 , lowercase_ : List[str]=768 , lowercase_ : List[Any]=12 , lowercase_ : int=12 , lowercase_ : Dict=3072 , lowercase_ : Dict="gelu" , lowercase_ : Dict=0.1 , lowercase_ : Any=0.1 , lowercase_ : Dict=512 , lowercase_ : Union[str, Any]=2 , lowercase_ : List[str]=0.02 , lowercase_ : Dict=1e-12 , lowercase_ : Dict=1 , lowercase_ : Optional[int]=0 , lowercase_ : Union[str, Any]=2 , lowercase_ : str="absolute" , lowercase_ : List[str]=True , lowercase_ : Tuple=None , lowercase_ : List[str]=False , lowercase_ : Union[str, Any]=2 , lowercase_ : Any=False , lowercase_ : Dict=True , lowercase_ : Optional[int]=True , lowercase_ : Optional[Any]=("en_XX",) , lowercase_ : Optional[int]=None , **lowercase_ : Optional[Any] , ): '''simple docstring''' super().__init__(pad_token_id=lowercase_ , bos_token_id=lowercase_ , eos_token_id=lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : Any = vocab_size SCREAMING_SNAKE_CASE_ : Optional[int] = hidden_size SCREAMING_SNAKE_CASE_ : List[str] = num_hidden_layers SCREAMING_SNAKE_CASE_ : Any = num_attention_heads SCREAMING_SNAKE_CASE_ : Union[str, Any] = hidden_act SCREAMING_SNAKE_CASE_ : Union[str, Any] = intermediate_size SCREAMING_SNAKE_CASE_ : List[Any] = hidden_dropout_prob SCREAMING_SNAKE_CASE_ : Union[str, Any] = attention_probs_dropout_prob SCREAMING_SNAKE_CASE_ : Union[str, Any] = max_position_embeddings SCREAMING_SNAKE_CASE_ : List[Any] = type_vocab_size SCREAMING_SNAKE_CASE_ : Any = initializer_range SCREAMING_SNAKE_CASE_ : Any = layer_norm_eps SCREAMING_SNAKE_CASE_ : Optional[Any] = position_embedding_type SCREAMING_SNAKE_CASE_ : Optional[Any] = use_cache SCREAMING_SNAKE_CASE_ : Dict = classifier_dropout SCREAMING_SNAKE_CASE_ : List[str] = pre_norm SCREAMING_SNAKE_CASE_ : Union[str, Any] = adapter_reduction_factor SCREAMING_SNAKE_CASE_ : int = adapter_layer_norm SCREAMING_SNAKE_CASE_ : List[Any] = adapter_reuse_layer_norm SCREAMING_SNAKE_CASE_ : str = ln_before_adapter SCREAMING_SNAKE_CASE_ : str = list(lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = default_language class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' @property def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' if self.task == "multiple-choice": SCREAMING_SNAKE_CASE_ : int = {0: '''batch''', 1: '''choice''', 2: '''sequence'''} else: SCREAMING_SNAKE_CASE_ : int = {0: '''batch''', 1: '''sequence'''} return OrderedDict( [ ('''input_ids''', dynamic_axis), ('''attention_mask''', dynamic_axis), ])
368
"""simple docstring""" import argparse import os import re import packaging.version UpperCAmelCase_ : Any = """examples/""" UpperCAmelCase_ : Optional[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"""), } UpperCAmelCase_ : List[Any] = { """init""": """src/transformers/__init__.py""", """setup""": """setup.py""", } UpperCAmelCase_ : Optional[int] = """README.md""" def _A (__a , __a , __a ) -> int: """simple docstring""" with open(__a , '''r''' , encoding='''utf-8''' , newline='''\n''' ) as f: SCREAMING_SNAKE_CASE_ : Optional[Any] = f.read() SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : List[Any] = REPLACE_PATTERNS[pattern] SCREAMING_SNAKE_CASE_ : Optional[int] = replace.replace('''VERSION''' , __a ) SCREAMING_SNAKE_CASE_ : Tuple = re_pattern.sub(__a , __a ) with open(__a , '''w''' , encoding='''utf-8''' , newline='''\n''' ) as f: f.write(__a ) def _A (__a ) -> int: """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 _A (__a , __a=False ) -> List[str]: """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 _A () -> int: """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[Any] = '''🤗 Transformers currently provides the following architectures''' SCREAMING_SNAKE_CASE_ : Optional[int] = '''1. Want to contribute a new model?''' with open(__a , '''r''' , encoding='''utf-8''' , newline='''\n''' ) as f: SCREAMING_SNAKE_CASE_ : Tuple = f.readlines() # Find the start of the list. SCREAMING_SNAKE_CASE_ : Tuple = 0 while not lines[start_index].startswith(_start_prompt ): start_index += 1 start_index += 1 SCREAMING_SNAKE_CASE_ : Dict = start_index # Update the lines in the model list. while not lines[index].startswith(_end_prompt ): if lines[index].startswith('''1.''' ): SCREAMING_SNAKE_CASE_ : List[Any] = 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 _A () -> List[str]: """simple docstring""" with open(REPLACE_FILES['''init'''] , '''r''' ) as f: SCREAMING_SNAKE_CASE_ : Any = f.read() SCREAMING_SNAKE_CASE_ : Dict = REPLACE_PATTERNS['''init'''][0].search(__a ).groups()[0] return packaging.version.parse(__a ) def _A (__a=False ) -> List[Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Tuple = 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: SCREAMING_SNAKE_CASE_ : List[Any] = default_version.base_version elif patch: SCREAMING_SNAKE_CASE_ : int = f'{default_version.major}.{default_version.minor}.{default_version.micro + 1}' else: SCREAMING_SNAKE_CASE_ : Any = f'{default_version.major}.{default_version.minor + 1}.0' # Now let's ask nicely if that's the right one. SCREAMING_SNAKE_CASE_ : int = input(f'Which version are you releasing? [{default_version}]' ) if len(__a ) == 0: SCREAMING_SNAKE_CASE_ : Optional[Any] = 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 _A () -> Any: """simple docstring""" SCREAMING_SNAKE_CASE_ : Any = get_version() SCREAMING_SNAKE_CASE_ : Any = f'{current_version.major}.{current_version.minor + 1}.0.dev0' SCREAMING_SNAKE_CASE_ : Union[str, Any] = current_version.base_version # Check with the user we got that right. SCREAMING_SNAKE_CASE_ : int = input(f'Which version are we developing now? [{dev_version}]' ) if len(__a ) == 0: SCREAMING_SNAKE_CASE_ : Optional[int] = 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__": UpperCAmelCase_ : Optional[int] = argparse.ArgumentParser() parser.add_argument("""--post_release""", action="""store_true""", help="""Whether this is pre or post release.""") parser.add_argument("""--patch""", action="""store_true""", help="""Whether or not this is a patch release.""") UpperCAmelCase_ : 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()
318
0
"""simple docstring""" from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging UpperCAmelCase_ : int = logging.get_logger(__name__) UpperCAmelCase_ : Any = { """distilbert-base-uncased""": """https://huggingface.co/distilbert-base-uncased/resolve/main/config.json""", """distilbert-base-uncased-distilled-squad""": ( """https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/config.json""" ), """distilbert-base-cased""": """https://huggingface.co/distilbert-base-cased/resolve/main/config.json""", """distilbert-base-cased-distilled-squad""": ( """https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/config.json""" ), """distilbert-base-german-cased""": """https://huggingface.co/distilbert-base-german-cased/resolve/main/config.json""", """distilbert-base-multilingual-cased""": ( """https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/config.json""" ), """distilbert-base-uncased-finetuned-sst-2-english""": ( """https://huggingface.co/distilbert-base-uncased-finetuned-sst-2-english/resolve/main/config.json""" ), } class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = "distilbert" __UpperCamelCase = { "hidden_size": "dim", "num_attention_heads": "n_heads", "num_hidden_layers": "n_layers", } def __init__( self : Any , lowercase_ : str=30522 , lowercase_ : Union[str, Any]=512 , lowercase_ : Union[str, Any]=False , lowercase_ : int=6 , lowercase_ : List[str]=12 , lowercase_ : Tuple=768 , lowercase_ : Tuple=4 * 768 , lowercase_ : Optional[Any]=0.1 , lowercase_ : Dict=0.1 , lowercase_ : str="gelu" , lowercase_ : List[Any]=0.02 , lowercase_ : Union[str, Any]=0.1 , lowercase_ : Optional[Any]=0.2 , lowercase_ : str=0 , **lowercase_ : int , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = vocab_size SCREAMING_SNAKE_CASE_ : Optional[Any] = max_position_embeddings SCREAMING_SNAKE_CASE_ : str = sinusoidal_pos_embds SCREAMING_SNAKE_CASE_ : List[Any] = n_layers SCREAMING_SNAKE_CASE_ : Dict = n_heads SCREAMING_SNAKE_CASE_ : Any = dim SCREAMING_SNAKE_CASE_ : Dict = hidden_dim SCREAMING_SNAKE_CASE_ : Union[str, Any] = dropout SCREAMING_SNAKE_CASE_ : str = attention_dropout SCREAMING_SNAKE_CASE_ : int = activation SCREAMING_SNAKE_CASE_ : Dict = initializer_range SCREAMING_SNAKE_CASE_ : Optional[Any] = qa_dropout SCREAMING_SNAKE_CASE_ : Tuple = seq_classif_dropout super().__init__(**lowercase_ , pad_token_id=lowercase_) class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' @property def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' if self.task == "multiple-choice": SCREAMING_SNAKE_CASE_ : List[str] = {0: '''batch''', 1: '''choice''', 2: '''sequence'''} else: SCREAMING_SNAKE_CASE_ : int = {0: '''batch''', 1: '''sequence'''} return OrderedDict( [ ('''input_ids''', dynamic_axis), ('''attention_mask''', dynamic_axis), ])
369
"""simple docstring""" from typing import Optional, Tuple import jax import jax.numpy as jnp from flax import linen as nn from flax.core.frozen_dict import FrozenDict from transformers import CLIPConfig, FlaxPreTrainedModel from transformers.models.clip.modeling_flax_clip import FlaxCLIPVisionModule def _A (__a , __a , __a=1e-12 ) -> List[Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Union[str, Any] = jnp.divide(emb_a.T , jnp.clip(jnp.linalg.norm(__a , axis=1 ) , a_min=__a ) ).T SCREAMING_SNAKE_CASE_ : List[Any] = jnp.divide(emb_a.T , jnp.clip(jnp.linalg.norm(__a , axis=1 ) , a_min=__a ) ).T return jnp.matmul(__a , norm_emb_a.T ) class lowerCAmelCase__ ( nn.Module ): '''simple docstring''' __UpperCamelCase = 42 __UpperCamelCase = jnp.floataa def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = FlaxCLIPVisionModule(self.config.vision_config) SCREAMING_SNAKE_CASE_ : Tuple = nn.Dense(self.config.projection_dim , use_bias=lowercase_ , dtype=self.dtype) SCREAMING_SNAKE_CASE_ : List[str] = self.param('''concept_embeds''' , jax.nn.initializers.ones , (17, self.config.projection_dim)) SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.param( '''special_care_embeds''' , jax.nn.initializers.ones , (3, self.config.projection_dim)) SCREAMING_SNAKE_CASE_ : Dict = self.param('''concept_embeds_weights''' , jax.nn.initializers.ones , (17,)) SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.param('''special_care_embeds_weights''' , jax.nn.initializers.ones , (3,)) def __call__( self : Optional[Any] , lowercase_ : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = self.vision_model(lowercase_)[1] SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.visual_projection(lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = jax_cosine_distance(lowercase_ , self.special_care_embeds) SCREAMING_SNAKE_CASE_ : List[str] = jax_cosine_distance(lowercase_ , self.concept_embeds) # increase this value to create a stronger `nfsw` filter # at the cost of increasing the possibility of filtering benign image inputs SCREAMING_SNAKE_CASE_ : Tuple = 0.0 SCREAMING_SNAKE_CASE_ : Dict = special_cos_dist - self.special_care_embeds_weights[None, :] + adjustment SCREAMING_SNAKE_CASE_ : Optional[int] = jnp.round(lowercase_ , 3) SCREAMING_SNAKE_CASE_ : List[Any] = jnp.any(special_scores > 0 , axis=1 , keepdims=lowercase_) # Use a lower threshold if an image has any special care concept SCREAMING_SNAKE_CASE_ : Dict = is_special_care * 0.01 SCREAMING_SNAKE_CASE_ : str = cos_dist - self.concept_embeds_weights[None, :] + special_adjustment SCREAMING_SNAKE_CASE_ : Any = jnp.round(lowercase_ , 3) SCREAMING_SNAKE_CASE_ : Dict = jnp.any(concept_scores > 0 , axis=1) return has_nsfw_concepts class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = CLIPConfig __UpperCamelCase = "clip_input" __UpperCamelCase = FlaxStableDiffusionSafetyCheckerModule def __init__( self : Union[str, Any] , lowercase_ : CLIPConfig , lowercase_ : Optional[Tuple] = None , lowercase_ : int = 0 , lowercase_ : jnp.dtype = jnp.floataa , lowercase_ : bool = True , **lowercase_ : Any , ): '''simple docstring''' if input_shape is None: SCREAMING_SNAKE_CASE_ : List[str] = (1, 224, 224, 3) SCREAMING_SNAKE_CASE_ : List[Any] = self.module_class(config=lowercase_ , dtype=lowercase_ , **lowercase_) super().__init__(lowercase_ , lowercase_ , input_shape=lowercase_ , seed=lowercase_ , dtype=lowercase_ , _do_init=_do_init) def _SCREAMING_SNAKE_CASE ( self : Tuple , lowercase_ : jax.random.KeyArray , lowercase_ : Tuple , lowercase_ : FrozenDict = None): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = jax.random.normal(lowercase_ , lowercase_) SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Union[str, Any] = jax.random.split(lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = {'''params''': params_rng, '''dropout''': dropout_rng} SCREAMING_SNAKE_CASE_ : List[Any] = self.module.init(lowercase_ , lowercase_)['''params'''] return random_params def __call__( self : List[Any] , lowercase_ : List[str] , lowercase_ : dict = None , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = jnp.transpose(lowercase_ , (0, 2, 3, 1)) return self.module.apply( {'''params''': params or self.params} , jnp.array(lowercase_ , dtype=jnp.floataa) , rngs={} , )
318
0
from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCAmelCase_ : Optional[int] = logging.get_logger(__name__) UpperCAmelCase_ : Tuple = { """google/pegasus-large""": """https://huggingface.co/google/pegasus-large/resolve/main/config.json""", # See all PEGASUS models at https://huggingface.co/models?filter=pegasus } class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = "pegasus" __UpperCamelCase = ["past_key_values"] __UpperCamelCase = {"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"} def __init__( self : Union[str, Any] , lowercase_ : Any=50265 , lowercase_ : Union[str, Any]=1024 , lowercase_ : Any=12 , lowercase_ : Optional[Any]=4096 , lowercase_ : Tuple=16 , lowercase_ : Dict=12 , lowercase_ : List[str]=4096 , lowercase_ : int=16 , lowercase_ : List[Any]=0.0 , lowercase_ : str=0.0 , lowercase_ : Tuple=True , lowercase_ : List[str]=True , lowercase_ : int="gelu" , lowercase_ : Dict=1024 , lowercase_ : str=0.1 , lowercase_ : str=0.0 , lowercase_ : Optional[Any]=0.0 , lowercase_ : List[str]=0.02 , lowercase_ : Optional[Any]=0 , lowercase_ : Union[str, Any]=False , lowercase_ : Dict=0 , lowercase_ : str=1 , lowercase_ : Tuple=1 , **lowercase_ : Union[str, Any] , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = vocab_size SCREAMING_SNAKE_CASE_ : str = max_position_embeddings SCREAMING_SNAKE_CASE_ : Union[str, Any] = d_model SCREAMING_SNAKE_CASE_ : int = encoder_ffn_dim SCREAMING_SNAKE_CASE_ : List[str] = encoder_layers SCREAMING_SNAKE_CASE_ : Dict = encoder_attention_heads SCREAMING_SNAKE_CASE_ : Dict = decoder_ffn_dim SCREAMING_SNAKE_CASE_ : List[str] = decoder_layers SCREAMING_SNAKE_CASE_ : List[str] = decoder_attention_heads SCREAMING_SNAKE_CASE_ : List[str] = dropout SCREAMING_SNAKE_CASE_ : Dict = attention_dropout SCREAMING_SNAKE_CASE_ : Tuple = activation_dropout SCREAMING_SNAKE_CASE_ : Dict = activation_function SCREAMING_SNAKE_CASE_ : Dict = init_std SCREAMING_SNAKE_CASE_ : List[str] = encoder_layerdrop SCREAMING_SNAKE_CASE_ : List[Any] = decoder_layerdrop SCREAMING_SNAKE_CASE_ : str = use_cache SCREAMING_SNAKE_CASE_ : Optional[int] = encoder_layers SCREAMING_SNAKE_CASE_ : Optional[Any] = scale_embedding # scale factor will be sqrt(d_model) if True super().__init__( pad_token_id=lowercase_ , eos_token_id=lowercase_ , is_encoder_decoder=lowercase_ , decoder_start_token_id=lowercase_ , forced_eos_token_id=lowercase_ , **lowercase_ , ) @property def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' return self.encoder_attention_heads @property def _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' return self.d_model
370
"""simple docstring""" from __future__ import annotations import queue class lowerCAmelCase__ : '''simple docstring''' def __init__( self : Tuple , lowercase_ : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = data SCREAMING_SNAKE_CASE_ : Tuple = None SCREAMING_SNAKE_CASE_ : Dict = None def _A () -> TreeNode: """simple docstring""" print('''\n********Press N to stop entering at any point of time********\n''' ) SCREAMING_SNAKE_CASE_ : List[Any] = input('''Enter the value of the root node: ''' ).strip().lower() SCREAMING_SNAKE_CASE_ : queue.Queue = queue.Queue() SCREAMING_SNAKE_CASE_ : Union[str, Any] = TreeNode(int(__a ) ) q.put(__a ) while not q.empty(): SCREAMING_SNAKE_CASE_ : Optional[int] = q.get() SCREAMING_SNAKE_CASE_ : List[str] = f'Enter the left node of {node_found.data}: ' SCREAMING_SNAKE_CASE_ : Optional[int] = input(__a ).strip().lower() or '''n''' if check == "n": return tree_node SCREAMING_SNAKE_CASE_ : List[str] = TreeNode(int(__a ) ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = left_node q.put(__a ) SCREAMING_SNAKE_CASE_ : str = f'Enter the right node of {node_found.data}: ' SCREAMING_SNAKE_CASE_ : str = input(__a ).strip().lower() or '''n''' if check == "n": return tree_node SCREAMING_SNAKE_CASE_ : Any = TreeNode(int(__a ) ) SCREAMING_SNAKE_CASE_ : int = right_node q.put(__a ) raise def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return print(node.data , end=''',''' ) pre_order(node.left ) pre_order(node.right ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return in_order(node.left ) print(node.data , end=''',''' ) in_order(node.right ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return post_order(node.left ) post_order(node.right ) print(node.data , end=''',''' ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ : queue.Queue = queue.Queue() q.put(__a ) while not q.empty(): SCREAMING_SNAKE_CASE_ : Tuple = q.get() print(node_dequeued.data , end=''',''' ) if node_dequeued.left: q.put(node_dequeued.left ) if node_dequeued.right: q.put(node_dequeued.right ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ : queue.Queue = queue.Queue() q.put(__a ) while not q.empty(): SCREAMING_SNAKE_CASE_ : str = [] while not q.empty(): SCREAMING_SNAKE_CASE_ : List[str] = q.get() print(node_dequeued.data , end=''',''' ) if node_dequeued.left: list_.append(node_dequeued.left ) if node_dequeued.right: list_.append(node_dequeued.right ) print() for node in list_: q.put(__a ) def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ : list[TreeNode] = [] SCREAMING_SNAKE_CASE_ : Union[str, Any] = node while n or stack: while n: # start from root node, find its left child print(n.data , end=''',''' ) stack.append(__a ) SCREAMING_SNAKE_CASE_ : Optional[Any] = n.left # end of while means current node doesn't have left child SCREAMING_SNAKE_CASE_ : Tuple = stack.pop() # start to traverse its right child SCREAMING_SNAKE_CASE_ : str = n.right def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ : list[TreeNode] = [] SCREAMING_SNAKE_CASE_ : Any = node while n or stack: while n: stack.append(__a ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = n.left SCREAMING_SNAKE_CASE_ : Any = stack.pop() print(n.data , end=''',''' ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = n.right def _A (__a ) -> None: """simple docstring""" if not isinstance(__a , __a ) or not node: return SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Any = [], [] SCREAMING_SNAKE_CASE_ : List[Any] = node stacka.append(__a ) while stacka: # to find the reversed order of post order, store it in stack2 SCREAMING_SNAKE_CASE_ : List[str] = stacka.pop() if n.left: stacka.append(n.left ) if n.right: stacka.append(n.right ) stacka.append(__a ) while stacka: # pop up from stack2 will be the post order print(stacka.pop().data , end=''',''' ) def _A (__a = "" , __a=50 , __a="*" ) -> str: """simple docstring""" if not s: return "\n" + width * char SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Dict = divmod(width - len(__a ) - 2 , 2 ) return f'{left * char} {s} {(left + extra) * char}' if __name__ == "__main__": import doctest doctest.testmod() print(prompt("""Binary Tree Traversals""")) UpperCAmelCase_ : TreeNode = build_tree() print(prompt("""Pre Order Traversal""")) pre_order(node) print(prompt() + """\n""") print(prompt("""In Order Traversal""")) in_order(node) print(prompt() + """\n""") print(prompt("""Post Order Traversal""")) post_order(node) print(prompt() + """\n""") print(prompt("""Level Order Traversal""")) level_order(node) print(prompt() + """\n""") print(prompt("""Actual Level Order Traversal""")) level_order_actual(node) print("""*""" * 50 + """\n""") print(prompt("""Pre Order Traversal - Iteration Version""")) pre_order_iter(node) print(prompt() + """\n""") print(prompt("""In Order Traversal - Iteration Version""")) in_order_iter(node) print(prompt() + """\n""") print(prompt("""Post Order Traversal - Iteration Version""")) post_order_iter(node) print(prompt())
318
0
"""simple docstring""" import operator def _A (__a , __a = False , __a = None ) -> list: """simple docstring""" SCREAMING_SNAKE_CASE_ : List[str] = operator.lt if reverse else operator.gt SCREAMING_SNAKE_CASE_ : List[Any] = solution or [] if not arr: return solution SCREAMING_SNAKE_CASE_ : Tuple = [arr.pop(0 )] for i, item in enumerate(__a ): if _operator(__a , sublist[-1] ): sublist.append(__a ) arr.pop(__a ) # merging sublist into solution list if not solution: solution.extend(__a ) else: while sublist: SCREAMING_SNAKE_CASE_ : List[Any] = sublist.pop(0 ) for i, xx in enumerate(__a ): if not _operator(__a , __a ): solution.insert(__a , __a ) break else: solution.append(__a ) strand_sort(__a , __a , __a ) return solution if __name__ == "__main__": assert strand_sort([4, 3, 5, 1, 2]) == [1, 2, 3, 4, 5] assert strand_sort([4, 3, 5, 1, 2], reverse=True) == [5, 4, 3, 2, 1]
371
"""simple docstring""" import random import unittest import numpy as np import torch from diffusers import ( DPMSolverMultistepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, LMSDiscreteScheduler, OnnxStableDiffusionUpscalePipeline, PNDMScheduler, ) from diffusers.utils import floats_tensor from diffusers.utils.testing_utils import ( is_onnx_available, load_image, nightly, require_onnxruntime, require_torch_gpu, ) from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin if is_onnx_available(): import onnxruntime as ort class lowerCAmelCase__ ( UpperCAmelCase__ , unittest.TestCase ): '''simple docstring''' __UpperCamelCase = "ssube/stable-diffusion-x4-upscaler-onnx" def _SCREAMING_SNAKE_CASE ( self : Optional[int] , lowercase_ : Union[str, Any]=0): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = floats_tensor((1, 3, 128, 128) , rng=random.Random(lowercase_)) SCREAMING_SNAKE_CASE_ : List[str] = torch.manual_seed(lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = { '''prompt''': '''A painting of a squirrel eating a burger''', '''image''': image, '''generator''': generator, '''num_inference_steps''': 3, '''guidance_scale''': 7.5, '''output_type''': '''numpy''', } return inputs def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''') pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : Tuple = self.get_dummy_inputs() SCREAMING_SNAKE_CASE_ : Union[str, Any] = pipe(**lowercase_).images SCREAMING_SNAKE_CASE_ : Dict = image[0, -3:, -3:, -1].flatten() # started as 128, should now be 512 assert image.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : Any = np.array( [0.6_97_47_82, 0.68_90_20_93, 0.70_13_58_85, 0.7_58_36_18, 0.7_80_45_45, 0.7_85_49_12, 0.78_66_74_26, 0.78_74_38_63, 0.78_07_02_23]) assert np.abs(image_slice - expected_slice).max() < 1e-1 def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''') SCREAMING_SNAKE_CASE_ : Optional[int] = PNDMScheduler.from_config(pipe.scheduler.config , skip_prk_steps=lowercase_) pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : Any = self.get_dummy_inputs() SCREAMING_SNAKE_CASE_ : Optional[Any] = pipe(**lowercase_).images SCREAMING_SNAKE_CASE_ : int = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : Any = np.array( [0.6_89_88_92, 0.59_24_05_56, 0.52_49_95_27, 0.58_86_62_15, 0.52_25_82_35, 0.52_57_27_15, 0.62_41_44_73, 0.6_17_43_87, 0.6_21_49_64]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-1 def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''') SCREAMING_SNAKE_CASE_ : Union[str, Any] = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = self.get_dummy_inputs() SCREAMING_SNAKE_CASE_ : Tuple = pipe(**lowercase_).images SCREAMING_SNAKE_CASE_ : Union[str, Any] = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : Tuple = np.array( [0.7_65_92_78, 0.76_43_76_64, 0.75_57_91_07, 0.7_69_11_16, 0.77_66_69_86, 0.7_72_76_72, 0.7_75_86_64, 0.7_81_22_26, 0.76_94_25_15]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-1 def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''') SCREAMING_SNAKE_CASE_ : List[Any] = EulerDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : Any = self.get_dummy_inputs() SCREAMING_SNAKE_CASE_ : Optional[Any] = pipe(**lowercase_).images SCREAMING_SNAKE_CASE_ : Optional[int] = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : Optional[Any] = np.array( [0.6_97_47_82, 0.68_90_20_93, 0.70_13_58_85, 0.7_58_36_18, 0.7_80_45_45, 0.7_85_49_12, 0.78_66_74_26, 0.78_74_38_63, 0.78_07_02_23]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-1 def _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''') SCREAMING_SNAKE_CASE_ : int = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = self.get_dummy_inputs() SCREAMING_SNAKE_CASE_ : Optional[int] = pipe(**lowercase_).images SCREAMING_SNAKE_CASE_ : str = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : int = np.array( [0.77_42_44_96, 0.77_36_01, 0.7_64_52_88, 0.7_76_95_98, 0.7_77_27_39, 0.7_73_86_88, 0.78_18_72_33, 0.77_87_95_84, 0.76_70_43]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-1 @nightly @require_onnxruntime @require_torch_gpu class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' @property def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' return ( "CUDAExecutionProvider", { "gpu_mem_limit": "15000000000", # 15GB "arena_extend_strategy": "kSameAsRequested", }, ) @property def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = ort.SessionOptions() SCREAMING_SNAKE_CASE_ : Optional[int] = False return options def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = load_image( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/img2img/sketch-mountains-input.jpg''') SCREAMING_SNAKE_CASE_ : Tuple = init_image.resize((128, 128)) # using the PNDM scheduler by default SCREAMING_SNAKE_CASE_ : List[str] = OnnxStableDiffusionUpscalePipeline.from_pretrained( '''ssube/stable-diffusion-x4-upscaler-onnx''' , provider=self.gpu_provider , sess_options=self.gpu_options , ) pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : Union[str, Any] = '''A fantasy landscape, trending on artstation''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = torch.manual_seed(0) SCREAMING_SNAKE_CASE_ : List[Any] = pipe( prompt=lowercase_ , image=lowercase_ , guidance_scale=7.5 , num_inference_steps=10 , generator=lowercase_ , output_type='''np''' , ) SCREAMING_SNAKE_CASE_ : Optional[int] = output.images SCREAMING_SNAKE_CASE_ : Optional[int] = images[0, 255:258, 383:386, -1] assert images.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : int = np.array([0.48_83, 0.49_47, 0.49_80, 0.49_75, 0.49_82, 0.49_80, 0.50_00, 0.50_06, 0.49_72]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2e-2 def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = load_image( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/img2img/sketch-mountains-input.jpg''') SCREAMING_SNAKE_CASE_ : Tuple = init_image.resize((128, 128)) SCREAMING_SNAKE_CASE_ : Tuple = LMSDiscreteScheduler.from_pretrained( '''ssube/stable-diffusion-x4-upscaler-onnx''' , subfolder='''scheduler''') SCREAMING_SNAKE_CASE_ : str = OnnxStableDiffusionUpscalePipeline.from_pretrained( '''ssube/stable-diffusion-x4-upscaler-onnx''' , scheduler=lowercase_ , provider=self.gpu_provider , sess_options=self.gpu_options , ) pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : int = '''A fantasy landscape, trending on artstation''' SCREAMING_SNAKE_CASE_ : List[Any] = torch.manual_seed(0) SCREAMING_SNAKE_CASE_ : int = pipe( prompt=lowercase_ , image=lowercase_ , guidance_scale=7.5 , num_inference_steps=20 , generator=lowercase_ , output_type='''np''' , ) SCREAMING_SNAKE_CASE_ : Optional[int] = output.images SCREAMING_SNAKE_CASE_ : Dict = images[0, 255:258, 383:386, -1] assert images.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_ : List[str] = np.array( [0.50_17_37_53, 0.50_22_33_56, 0.50_20_39, 0.50_23_30_36, 0.5_02_37_25, 0.5_02_26_01, 0.5_01_87_58, 0.50_23_40_85, 0.50_24_15_66]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2e-2
318
0
"""simple docstring""" import unittest from transformers import AlbertConfig, is_torch_available from transformers.models.auto import get_values from transformers.testing_utils import require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( MODEL_FOR_PRETRAINING_MAPPING, AlbertForMaskedLM, AlbertForMultipleChoice, AlbertForPreTraining, AlbertForQuestionAnswering, AlbertForSequenceClassification, AlbertForTokenClassification, AlbertModel, ) from transformers.models.albert.modeling_albert import ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST class lowerCAmelCase__ : '''simple docstring''' def __init__( self : Any , lowercase_ : Tuple , lowercase_ : Dict=13 , lowercase_ : Tuple=7 , lowercase_ : Tuple=True , lowercase_ : List[str]=True , lowercase_ : List[str]=True , lowercase_ : List[str]=True , lowercase_ : str=99 , lowercase_ : Tuple=16 , lowercase_ : List[Any]=36 , lowercase_ : Optional[Any]=6 , lowercase_ : Union[str, Any]=6 , lowercase_ : List[str]=6 , lowercase_ : int=37 , lowercase_ : Dict="gelu" , lowercase_ : Tuple=0.1 , lowercase_ : str=0.1 , lowercase_ : Optional[Any]=512 , lowercase_ : Union[str, Any]=16 , lowercase_ : int=2 , lowercase_ : Optional[Any]=0.02 , lowercase_ : Tuple=3 , lowercase_ : Optional[Any]=4 , lowercase_ : List[str]=None , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = parent SCREAMING_SNAKE_CASE_ : Union[str, Any] = batch_size SCREAMING_SNAKE_CASE_ : Optional[Any] = seq_length SCREAMING_SNAKE_CASE_ : int = is_training SCREAMING_SNAKE_CASE_ : Tuple = use_input_mask SCREAMING_SNAKE_CASE_ : List[str] = use_token_type_ids SCREAMING_SNAKE_CASE_ : str = use_labels SCREAMING_SNAKE_CASE_ : Tuple = vocab_size SCREAMING_SNAKE_CASE_ : List[str] = embedding_size SCREAMING_SNAKE_CASE_ : List[str] = hidden_size SCREAMING_SNAKE_CASE_ : Tuple = num_hidden_layers SCREAMING_SNAKE_CASE_ : Tuple = num_hidden_groups SCREAMING_SNAKE_CASE_ : Optional[Any] = num_attention_heads SCREAMING_SNAKE_CASE_ : Optional[Any] = intermediate_size SCREAMING_SNAKE_CASE_ : Any = hidden_act SCREAMING_SNAKE_CASE_ : Union[str, Any] = hidden_dropout_prob SCREAMING_SNAKE_CASE_ : Optional[int] = attention_probs_dropout_prob SCREAMING_SNAKE_CASE_ : int = max_position_embeddings SCREAMING_SNAKE_CASE_ : Any = type_vocab_size SCREAMING_SNAKE_CASE_ : Dict = type_sequence_label_size SCREAMING_SNAKE_CASE_ : str = initializer_range SCREAMING_SNAKE_CASE_ : Union[str, Any] = num_labels SCREAMING_SNAKE_CASE_ : str = num_choices SCREAMING_SNAKE_CASE_ : int = scope def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[str] = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size) SCREAMING_SNAKE_CASE_ : Optional[int] = None if self.use_input_mask: SCREAMING_SNAKE_CASE_ : Optional[int] = random_attention_mask([self.batch_size, self.seq_length]) SCREAMING_SNAKE_CASE_ : str = None if self.use_token_type_ids: SCREAMING_SNAKE_CASE_ : List[str] = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size) SCREAMING_SNAKE_CASE_ : Any = None SCREAMING_SNAKE_CASE_ : List[Any] = None SCREAMING_SNAKE_CASE_ : Any = None if self.use_labels: SCREAMING_SNAKE_CASE_ : str = ids_tensor([self.batch_size] , self.type_sequence_label_size) SCREAMING_SNAKE_CASE_ : Any = ids_tensor([self.batch_size, self.seq_length] , self.num_labels) SCREAMING_SNAKE_CASE_ : int = ids_tensor([self.batch_size] , self.num_choices) SCREAMING_SNAKE_CASE_ : int = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' return AlbertConfig( 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 , num_hidden_groups=self.num_hidden_groups , ) def _SCREAMING_SNAKE_CASE ( self : List[Any] , lowercase_ : List[str] , lowercase_ : Optional[int] , lowercase_ : List[Any] , lowercase_ : str , lowercase_ : Optional[int] , lowercase_ : Dict , lowercase_ : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = AlbertModel(config=lowercase_) model.to(lowercase_) model.eval() SCREAMING_SNAKE_CASE_ : Optional[Any] = model(lowercase_ , attention_mask=lowercase_ , token_type_ids=lowercase_) SCREAMING_SNAKE_CASE_ : Any = model(lowercase_ , token_type_ids=lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = model(lowercase_) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size)) self.parent.assertEqual(result.pooler_output.shape , (self.batch_size, self.hidden_size)) def _SCREAMING_SNAKE_CASE ( self : str , lowercase_ : Dict , lowercase_ : Any , lowercase_ : List[str] , lowercase_ : Optional[Any] , lowercase_ : List[Any] , lowercase_ : str , lowercase_ : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = AlbertForPreTraining(config=lowercase_) model.to(lowercase_) model.eval() SCREAMING_SNAKE_CASE_ : List[Any] = model( lowercase_ , attention_mask=lowercase_ , token_type_ids=lowercase_ , labels=lowercase_ , sentence_order_label=lowercase_ , ) self.parent.assertEqual(result.prediction_logits.shape , (self.batch_size, self.seq_length, self.vocab_size)) self.parent.assertEqual(result.sop_logits.shape , (self.batch_size, config.num_labels)) def _SCREAMING_SNAKE_CASE ( self : Tuple , lowercase_ : List[Any] , lowercase_ : List[Any] , lowercase_ : Optional[int] , lowercase_ : Union[str, Any] , lowercase_ : int , lowercase_ : str , lowercase_ : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = AlbertForMaskedLM(config=lowercase_) model.to(lowercase_) model.eval() SCREAMING_SNAKE_CASE_ : Optional[Any] = model(lowercase_ , attention_mask=lowercase_ , token_type_ids=lowercase_ , labels=lowercase_) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size)) def _SCREAMING_SNAKE_CASE ( self : Tuple , lowercase_ : int , lowercase_ : List[str] , lowercase_ : Tuple , lowercase_ : str , lowercase_ : Optional[int] , lowercase_ : Any , lowercase_ : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = AlbertForQuestionAnswering(config=lowercase_) model.to(lowercase_) model.eval() SCREAMING_SNAKE_CASE_ : Tuple = model( lowercase_ , attention_mask=lowercase_ , token_type_ids=lowercase_ , start_positions=lowercase_ , end_positions=lowercase_ , ) 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 _SCREAMING_SNAKE_CASE ( self : Any , lowercase_ : Optional[int] , lowercase_ : Any , lowercase_ : Tuple , lowercase_ : List[Any] , lowercase_ : Any , lowercase_ : List[str] , lowercase_ : Tuple): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = self.num_labels SCREAMING_SNAKE_CASE_ : Union[str, Any] = AlbertForSequenceClassification(lowercase_) model.to(lowercase_) model.eval() SCREAMING_SNAKE_CASE_ : str = model(lowercase_ , attention_mask=lowercase_ , token_type_ids=lowercase_ , labels=lowercase_) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels)) def _SCREAMING_SNAKE_CASE ( self : List[str] , lowercase_ : Dict , lowercase_ : int , lowercase_ : Dict , lowercase_ : str , lowercase_ : List[str] , lowercase_ : Any , lowercase_ : Any): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = self.num_labels SCREAMING_SNAKE_CASE_ : str = AlbertForTokenClassification(config=lowercase_) model.to(lowercase_) model.eval() SCREAMING_SNAKE_CASE_ : Optional[Any] = model(lowercase_ , attention_mask=lowercase_ , token_type_ids=lowercase_ , labels=lowercase_) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels)) def _SCREAMING_SNAKE_CASE ( self : Optional[Any] , lowercase_ : Union[str, Any] , lowercase_ : List[Any] , lowercase_ : str , lowercase_ : str , lowercase_ : Dict , lowercase_ : Any , lowercase_ : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = self.num_choices SCREAMING_SNAKE_CASE_ : Optional[Any] = AlbertForMultipleChoice(config=lowercase_) model.to(lowercase_) model.eval() SCREAMING_SNAKE_CASE_ : Tuple = input_ids.unsqueeze(1).expand(-1 , self.num_choices , -1).contiguous() SCREAMING_SNAKE_CASE_ : Dict = token_type_ids.unsqueeze(1).expand(-1 , self.num_choices , -1).contiguous() SCREAMING_SNAKE_CASE_ : int = input_mask.unsqueeze(1).expand(-1 , self.num_choices , -1).contiguous() SCREAMING_SNAKE_CASE_ : str = model( lowercase_ , attention_mask=lowercase_ , token_type_ids=lowercase_ , labels=lowercase_ , ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices)) def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = self.prepare_config_and_inputs() ( SCREAMING_SNAKE_CASE_ ) : Dict = config_and_inputs SCREAMING_SNAKE_CASE_ : Any = {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask} return config, inputs_dict @require_torch class lowerCAmelCase__ ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): '''simple docstring''' __UpperCamelCase = ( ( AlbertModel, AlbertForPreTraining, AlbertForMaskedLM, AlbertForMultipleChoice, AlbertForSequenceClassification, AlbertForTokenClassification, AlbertForQuestionAnswering, ) if is_torch_available() else () ) __UpperCamelCase = ( { "feature-extraction": AlbertModel, "fill-mask": AlbertForMaskedLM, "question-answering": AlbertForQuestionAnswering, "text-classification": AlbertForSequenceClassification, "token-classification": AlbertForTokenClassification, "zero-shot": AlbertForSequenceClassification, } if is_torch_available() else {} ) __UpperCamelCase = True def _SCREAMING_SNAKE_CASE ( self : Dict , lowercase_ : Optional[Any] , lowercase_ : Union[str, Any] , lowercase_ : Optional[int]=False): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = super()._prepare_for_class(lowercase_ , lowercase_ , return_labels=lowercase_) if return_labels: if model_class in get_values(lowercase_): SCREAMING_SNAKE_CASE_ : List[Any] = torch.zeros( (self.model_tester.batch_size, self.model_tester.seq_length) , dtype=torch.long , device=lowercase_) SCREAMING_SNAKE_CASE_ : str = torch.zeros( self.model_tester.batch_size , dtype=torch.long , device=lowercase_) return inputs_dict def _SCREAMING_SNAKE_CASE ( self : Any): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = AlbertModelTester(self) SCREAMING_SNAKE_CASE_ : Union[str, Any] = ConfigTester(self , config_class=lowercase_ , hidden_size=37) def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' self.config_tester.run_common_tests() def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*lowercase_) def _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_pretraining(*lowercase_) def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*lowercase_) def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_multiple_choice(*lowercase_) def _SCREAMING_SNAKE_CASE ( self : Tuple): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_question_answering(*lowercase_) def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_sequence_classification(*lowercase_) def _SCREAMING_SNAKE_CASE ( self : Any): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = self.model_tester.prepare_config_and_inputs() for type in ["absolute", "relative_key", "relative_key_query"]: SCREAMING_SNAKE_CASE_ : Dict = type self.model_tester.create_and_check_model(*lowercase_) @slow def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' for model_name in ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: SCREAMING_SNAKE_CASE_ : Dict = AlbertModel.from_pretrained(lowercase_) self.assertIsNotNone(lowercase_) @require_torch class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' @slow def _SCREAMING_SNAKE_CASE ( self : Tuple): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = AlbertModel.from_pretrained('''albert-base-v2''') SCREAMING_SNAKE_CASE_ : str = torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]) SCREAMING_SNAKE_CASE_ : Optional[Any] = torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]) with torch.no_grad(): SCREAMING_SNAKE_CASE_ : List[str] = model(lowercase_ , attention_mask=lowercase_)[0] SCREAMING_SNAKE_CASE_ : Tuple = torch.Size((1, 11, 768)) self.assertEqual(output.shape , lowercase_) SCREAMING_SNAKE_CASE_ : Any = torch.tensor( [[[-0.65_13, 1.50_35, -0.27_66], [-0.65_15, 1.50_46, -0.27_80], [-0.65_12, 1.50_49, -0.27_84]]]) self.assertTrue(torch.allclose(output[:, 1:4, 1:4] , lowercase_ , atol=1e-4))
350
"""simple docstring""" from scipy.stats import pearsonr import datasets UpperCAmelCase_ : List[Any] = """ Pearson correlation coefficient and p-value for testing non-correlation. The Pearson correlation coefficient measures the linear relationship between two datasets. The calculation of the p-value relies on the assumption that each dataset is normally distributed. Like other correlation coefficients, this one varies between -1 and +1 with 0 implying no correlation. Correlations of -1 or +1 imply an exact linear relationship. Positive correlations imply that as x increases, so does y. Negative correlations imply that as x increases, y decreases. The p-value roughly indicates the probability of an uncorrelated system producing datasets that have a Pearson correlation at least as extreme as the one computed from these datasets. """ UpperCAmelCase_ : Optional[int] = """ Args: predictions (`list` of `int`): Predicted class labels, as returned by a model. references (`list` of `int`): Ground truth labels. return_pvalue (`boolean`): If `True`, returns the p-value, along with the correlation coefficient. If `False`, returns only the correlation coefficient. Defaults to `False`. Returns: pearsonr (`float`): Pearson correlation coefficient. Minimum possible value is -1. Maximum possible value is 1. Values of 1 and -1 indicate exact linear positive and negative relationships, respectively. A value of 0 implies no correlation. p-value (`float`): P-value, which roughly indicates the probability of an The p-value roughly indicates the probability of an uncorrelated system producing datasets that have a Pearson correlation at least as extreme as the one computed from these datasets. Minimum possible value is 0. Maximum possible value is 1. Higher values indicate higher probabilities. Examples: Example 1-A simple example using only predictions and references. >>> pearsonr_metric = datasets.load_metric(\"pearsonr\") >>> results = pearsonr_metric.compute(predictions=[10, 9, 2.5, 6, 4], references=[1, 2, 3, 4, 5]) >>> print(round(results['pearsonr'], 2)) -0.74 Example 2-The same as Example 1, but that also returns the `p-value`. >>> pearsonr_metric = datasets.load_metric(\"pearsonr\") >>> results = pearsonr_metric.compute(predictions=[10, 9, 2.5, 6, 4], references=[1, 2, 3, 4, 5], return_pvalue=True) >>> print(sorted(list(results.keys()))) ['p-value', 'pearsonr'] >>> print(round(results['pearsonr'], 2)) -0.74 >>> print(round(results['p-value'], 2)) 0.15 """ UpperCAmelCase_ : Tuple = """ @article{2020SciPy-NMeth, author = {Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E. and Haberland, Matt and Reddy, Tyler and Cournapeau, David and Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and Bright, Jonathan and {van der Walt}, St{\'e}fan J. and Brett, Matthew and Wilson, Joshua and Millman, K. Jarrod and Mayorov, Nikolay and Nelson, Andrew R. J. and Jones, Eric and Kern, Robert and Larson, Eric and Carey, C J and Polat, Ilhan and Feng, Yu and Moore, Eric W. and {VanderPlas}, Jake and Laxalde, Denis and Perktold, Josef and Cimrman, Robert and Henriksen, Ian and Quintero, E. A. and Harris, Charles R. and Archibald, Anne M. and Ribeiro, Antonio H. and Pedregosa, Fabian and {van Mulbregt}, Paul and {SciPy 1.0 Contributors}}, title = {{{SciPy} 1.0: Fundamental Algorithms for Scientific Computing in Python}}, journal = {Nature Methods}, year = {2020}, volume = {17}, pages = {261--272}, adsurl = {https://rdcu.be/b08Wh}, doi = {10.1038/s41592-019-0686-2}, } """ @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class lowerCAmelCase__ ( datasets.Metric ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { '''predictions''': datasets.Value('''float'''), '''references''': datasets.Value('''float'''), }) , reference_urls=['''https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.pearsonr.html'''] , ) def _SCREAMING_SNAKE_CASE ( self : List[Any] , lowercase_ : List[str] , lowercase_ : List[Any] , lowercase_ : Union[str, Any]=False): '''simple docstring''' if return_pvalue: SCREAMING_SNAKE_CASE_ : int = pearsonr(lowercase_ , lowercase_) return {"pearsonr": results[0], "p-value": results[1]} else: return {"pearsonr": float(pearsonr(lowercase_ , lowercase_)[0])}
318
0
"""simple docstring""" from typing import Union import fire import torch from tqdm import tqdm def _A (__a , __a = "cpu" , __a = None ) -> None: """simple docstring""" SCREAMING_SNAKE_CASE_ : str = torch.load(__a , map_location=__a ) for k, v in tqdm(state_dict.items() ): if not isinstance(__a , torch.Tensor ): raise TypeError('''FP16 conversion only works on paths that are saved state dicts, like pytorch_model.bin''' ) SCREAMING_SNAKE_CASE_ : Optional[int] = v.half() if save_path is None: # overwrite src_path SCREAMING_SNAKE_CASE_ : Union[str, Any] = src_path torch.save(__a , __a ) if __name__ == "__main__": fire.Fire(convert)
351
"""simple docstring""" import os from typing import Dict, List, Union import tensorflow as tf from keras_nlp.tokenizers import BytePairTokenizer from tensorflow_text import pad_model_inputs from .tokenization_gpta import GPTaTokenizer class lowerCAmelCase__ ( tf.keras.layers.Layer ): '''simple docstring''' def __init__( self : Any , lowercase_ : Dict[str, int] , lowercase_ : List[str] , lowercase_ : int = None , lowercase_ : int = None): '''simple docstring''' super().__init__() SCREAMING_SNAKE_CASE_ : str = pad_token_id SCREAMING_SNAKE_CASE_ : Optional[int] = max_length SCREAMING_SNAKE_CASE_ : Dict = vocab SCREAMING_SNAKE_CASE_ : Dict = merges SCREAMING_SNAKE_CASE_ : Union[str, Any] = BytePairTokenizer(lowercase_ , lowercase_ , sequence_length=lowercase_) @classmethod def _SCREAMING_SNAKE_CASE ( cls : Dict , lowercase_ : GPTaTokenizer , *lowercase_ : Optional[Any] , **lowercase_ : Tuple): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = [''' '''.join(lowercase_) for m in tokenizer.bpe_ranks.keys()] SCREAMING_SNAKE_CASE_ : str = tokenizer.get_vocab() return cls(lowercase_ , lowercase_ , *lowercase_ , **lowercase_) @classmethod def _SCREAMING_SNAKE_CASE ( cls : int , lowercase_ : Union[str, os.PathLike] , *lowercase_ : List[str] , **lowercase_ : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = GPTaTokenizer.from_pretrained(lowercase_ , *lowercase_ , **lowercase_) return cls.from_tokenizer(lowercase_ , *lowercase_ , **lowercase_) @classmethod def _SCREAMING_SNAKE_CASE ( cls : Dict , lowercase_ : List[Any]): '''simple docstring''' return cls(**lowercase_) def _SCREAMING_SNAKE_CASE ( self : Tuple): '''simple docstring''' return { "vocab": self.vocab, "merges": self.merges, "max_length": self.max_length, "pad_token_id": self.pad_token_id, } def _SCREAMING_SNAKE_CASE ( self : Any , lowercase_ : List[Any] , lowercase_ : int = None): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = self.tf_tokenizer(lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = tf.ones_like(lowercase_) if self.pad_token_id is not None: # pad the tokens up to max length SCREAMING_SNAKE_CASE_ : Union[str, Any] = max_length if max_length is not None else self.max_length if max_length is not None: SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : List[str] = pad_model_inputs( lowercase_ , max_seq_length=lowercase_ , pad_value=self.pad_token_id) return {"attention_mask": attention_mask, "input_ids": input_ids}
318
0
"""simple docstring""" from __future__ import annotations import math def _A (__a ) -> bool: """simple docstring""" if 1 < number < 4: # 2 and 3 are primes return True elif number < 2 or number % 2 == 0 or number % 3 == 0: # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes return False # All primes number are in format of 6k +/- 1 for i in range(5 , int(math.sqrt(__a ) + 1 ) , 6 ): if number % i == 0 or number % (i + 2) == 0: return False return True def _A (__a ) -> list[int]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[int] = str(__a ) SCREAMING_SNAKE_CASE_ : str = [n] for i in range(1 , len(__a ) ): list_nums.append(int(str_num[i:] ) ) list_nums.append(int(str_num[:-i] ) ) return list_nums def _A (__a ) -> bool: """simple docstring""" if len(str(__a ) ) > 3: if not is_prime(int(str(__a )[-3:] ) ) or not is_prime(int(str(__a )[:3] ) ): return False return True def _A (__a = 11 ) -> list[int]: """simple docstring""" SCREAMING_SNAKE_CASE_ : list[int] = [] SCREAMING_SNAKE_CASE_ : Optional[Any] = 13 while len(__a ) != count: if validate(__a ): SCREAMING_SNAKE_CASE_ : Tuple = list_truncated_nums(__a ) if all(is_prime(__a ) for i in list_nums ): list_truncated_primes.append(__a ) num += 2 return list_truncated_primes def _A () -> int: """simple docstring""" return sum(compute_truncated_primes(11 ) ) if __name__ == "__main__": print(f'''{sum(compute_truncated_primes(11)) = }''')
352
"""simple docstring""" import json import os import shutil import tempfile import unittest import numpy as np import pytest from transformers import BertTokenizer, BertTokenizerFast from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES from transformers.testing_utils import require_vision from transformers.utils import FEATURE_EXTRACTOR_NAME, is_vision_available if is_vision_available(): from PIL import Image from transformers import ChineseCLIPImageProcessor, ChineseCLIPProcessor @require_vision class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = tempfile.mkdtemp() SCREAMING_SNAKE_CASE_ : Union[str, Any] = [ '''[UNK]''', '''[CLS]''', '''[SEP]''', '''[PAD]''', '''[MASK]''', '''的''', '''价''', '''格''', '''是''', '''15''', '''便''', '''alex''', '''##andra''', ''',''', '''。''', '''-''', '''t''', '''shirt''', ] SCREAMING_SNAKE_CASE_ : int = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['''vocab_file''']) with open(self.vocab_file , '''w''' , encoding='''utf-8''') as vocab_writer: vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens])) SCREAMING_SNAKE_CASE_ : Dict = { '''do_resize''': True, '''size''': {'''height''': 224, '''width''': 224}, '''do_center_crop''': True, '''crop_size''': {'''height''': 18, '''width''': 18}, '''do_normalize''': True, '''image_mean''': [0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73], '''image_std''': [0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11], '''do_convert_rgb''': True, } SCREAMING_SNAKE_CASE_ : int = os.path.join(self.tmpdirname , lowercase_) with open(self.image_processor_file , '''w''' , encoding='''utf-8''') as fp: json.dump(lowercase_ , lowercase_) def _SCREAMING_SNAKE_CASE ( self : Optional[int] , **lowercase_ : str): '''simple docstring''' return BertTokenizer.from_pretrained(self.tmpdirname , **lowercase_) def _SCREAMING_SNAKE_CASE ( self : Tuple , **lowercase_ : List[Any]): '''simple docstring''' return BertTokenizerFast.from_pretrained(self.tmpdirname , **lowercase_) def _SCREAMING_SNAKE_CASE ( self : List[Any] , **lowercase_ : str): '''simple docstring''' return ChineseCLIPImageProcessor.from_pretrained(self.tmpdirname , **lowercase_) def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' shutil.rmtree(self.tmpdirname) def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = [np.random.randint(255 , size=(3, 30, 400) , dtype=np.uinta)] SCREAMING_SNAKE_CASE_ : Dict = [Image.fromarray(np.moveaxis(lowercase_ , 0 , -1)) for x in image_inputs] return image_inputs def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.get_rust_tokenizer() SCREAMING_SNAKE_CASE_ : Any = self.get_image_processor() SCREAMING_SNAKE_CASE_ : int = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) processor_slow.save_pretrained(self.tmpdirname) SCREAMING_SNAKE_CASE_ : Optional[int] = ChineseCLIPProcessor.from_pretrained(self.tmpdirname , use_fast=lowercase_) SCREAMING_SNAKE_CASE_ : Any = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) processor_fast.save_pretrained(self.tmpdirname) SCREAMING_SNAKE_CASE_ : int = ChineseCLIPProcessor.from_pretrained(self.tmpdirname) self.assertEqual(processor_slow.tokenizer.get_vocab() , tokenizer_slow.get_vocab()) self.assertEqual(processor_fast.tokenizer.get_vocab() , tokenizer_fast.get_vocab()) self.assertEqual(tokenizer_slow.get_vocab() , tokenizer_fast.get_vocab()) self.assertIsInstance(processor_slow.tokenizer , lowercase_) self.assertIsInstance(processor_fast.tokenizer , lowercase_) self.assertEqual(processor_slow.image_processor.to_json_string() , image_processor.to_json_string()) self.assertEqual(processor_fast.image_processor.to_json_string() , image_processor.to_json_string()) self.assertIsInstance(processor_slow.image_processor , lowercase_) self.assertIsInstance(processor_fast.image_processor , lowercase_) def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = ChineseCLIPProcessor(tokenizer=self.get_tokenizer() , image_processor=self.get_image_processor()) processor.save_pretrained(self.tmpdirname) SCREAMING_SNAKE_CASE_ : Optional[int] = self.get_tokenizer(cls_token='''(CLS)''' , sep_token='''(SEP)''') SCREAMING_SNAKE_CASE_ : Optional[int] = self.get_image_processor(do_normalize=lowercase_) SCREAMING_SNAKE_CASE_ : Tuple = ChineseCLIPProcessor.from_pretrained( self.tmpdirname , cls_token='''(CLS)''' , sep_token='''(SEP)''' , do_normalize=lowercase_) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab()) self.assertIsInstance(processor.tokenizer , lowercase_) self.assertEqual(processor.image_processor.to_json_string() , image_processor_add_kwargs.to_json_string()) self.assertIsInstance(processor.image_processor , lowercase_) def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = self.get_image_processor() SCREAMING_SNAKE_CASE_ : List[Any] = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : Tuple = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = self.prepare_image_inputs() SCREAMING_SNAKE_CASE_ : Any = image_processor(lowercase_ , return_tensors='''np''') SCREAMING_SNAKE_CASE_ : Union[str, Any] = processor(images=lowercase_ , return_tensors='''np''') for key in input_feat_extract.keys(): self.assertAlmostEqual(input_feat_extract[key].sum() , input_processor[key].sum() , delta=1e-2) def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = self.get_image_processor() SCREAMING_SNAKE_CASE_ : Any = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : str = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) SCREAMING_SNAKE_CASE_ : Dict = '''Alexandra,T-shirt的价格是15便士。''' SCREAMING_SNAKE_CASE_ : Optional[Any] = processor(text=lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = tokenizer(lowercase_) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key]) def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = self.get_image_processor() SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : int = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) SCREAMING_SNAKE_CASE_ : Union[str, Any] = '''Alexandra,T-shirt的价格是15便士。''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.prepare_image_inputs() SCREAMING_SNAKE_CASE_ : int = processor(text=lowercase_ , images=lowercase_) self.assertListEqual(list(inputs.keys()) , ['''input_ids''', '''token_type_ids''', '''attention_mask''', '''pixel_values''']) # test if it raises when no input is passed with pytest.raises(lowercase_): processor() def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.get_image_processor() SCREAMING_SNAKE_CASE_ : List[Any] = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : Optional[int] = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) SCREAMING_SNAKE_CASE_ : Any = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] SCREAMING_SNAKE_CASE_ : Optional[int] = processor.batch_decode(lowercase_) SCREAMING_SNAKE_CASE_ : Dict = tokenizer.batch_decode(lowercase_) self.assertListEqual(lowercase_ , lowercase_) def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = self.get_image_processor() SCREAMING_SNAKE_CASE_ : Dict = self.get_tokenizer() SCREAMING_SNAKE_CASE_ : Dict = ChineseCLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = '''Alexandra,T-shirt的价格是15便士。''' SCREAMING_SNAKE_CASE_ : Dict = self.prepare_image_inputs() SCREAMING_SNAKE_CASE_ : Dict = processor(text=lowercase_ , images=lowercase_) self.assertListEqual(list(inputs.keys()) , processor.model_input_names)
318
0
"""simple docstring""" import gc import random import unittest import numpy as np import torch from transformers import XLMRobertaTokenizer from diffusers import ( AltDiffusionImgaImgPipeline, AutoencoderKL, PNDMScheduler, UNetaDConditionModel, ) from diffusers.image_processor import VaeImageProcessor from diffusers.pipelines.alt_diffusion.modeling_roberta_series import ( RobertaSeriesConfig, RobertaSeriesModelWithTransformation, ) from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu enable_full_determinism() class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' super().tearDown() gc.collect() torch.cuda.empty_cache() @property def _SCREAMING_SNAKE_CASE ( self : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = 1 SCREAMING_SNAKE_CASE_ : Union[str, Any] = 3 SCREAMING_SNAKE_CASE_ : Tuple = (32, 32) SCREAMING_SNAKE_CASE_ : Union[str, Any] = floats_tensor((batch_size, num_channels) + sizes , rng=random.Random(0)).to(lowercase_) return image @property def _SCREAMING_SNAKE_CASE ( self : Tuple): '''simple docstring''' torch.manual_seed(0) SCREAMING_SNAKE_CASE_ : List[Any] = UNetaDConditionModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=4 , out_channels=4 , down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''') , up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''') , cross_attention_dim=32 , ) return model @property def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' torch.manual_seed(0) SCREAMING_SNAKE_CASE_ : int = AutoencoderKL( block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D'''] , up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D'''] , latent_channels=4 , ) return model @property def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' torch.manual_seed(0) SCREAMING_SNAKE_CASE_ : Dict = RobertaSeriesConfig( hidden_size=32 , project_dim=32 , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=5006 , ) return RobertaSeriesModelWithTransformation(lowercase_) @property def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' def extract(*lowercase_ : List[Any] , **lowercase_ : List[Any]): class lowerCAmelCase__ : '''simple docstring''' def __init__( self : Optional[int]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = torch.ones([0]) def _SCREAMING_SNAKE_CASE ( self : str , lowercase_ : Any): '''simple docstring''' self.pixel_values.to(lowercase_) return self return Out() return extract def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = '''cpu''' # ensure determinism for the device-dependent torch.Generator SCREAMING_SNAKE_CASE_ : Tuple = self.dummy_cond_unet SCREAMING_SNAKE_CASE_ : int = PNDMScheduler(skip_prk_steps=lowercase_) SCREAMING_SNAKE_CASE_ : Tuple = self.dummy_vae SCREAMING_SNAKE_CASE_ : List[str] = self.dummy_text_encoder SCREAMING_SNAKE_CASE_ : Union[str, Any] = XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta''') SCREAMING_SNAKE_CASE_ : List[Any] = 77 SCREAMING_SNAKE_CASE_ : List[Any] = self.dummy_image.to(lowercase_) SCREAMING_SNAKE_CASE_ : Dict = init_image / 2 + 0.5 # make sure here that pndm scheduler skips prk SCREAMING_SNAKE_CASE_ : Dict = AltDiffusionImgaImgPipeline( unet=lowercase_ , scheduler=lowercase_ , vae=lowercase_ , text_encoder=lowercase_ , tokenizer=lowercase_ , safety_checker=lowercase_ , feature_extractor=self.dummy_extractor , ) SCREAMING_SNAKE_CASE_ : Dict = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor , do_normalize=lowercase_) SCREAMING_SNAKE_CASE_ : Union[str, Any] = alt_pipe.to(lowercase_) alt_pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : str = '''A painting of a squirrel eating a burger''' SCREAMING_SNAKE_CASE_ : Dict = torch.Generator(device=lowercase_).manual_seed(0) SCREAMING_SNAKE_CASE_ : int = alt_pipe( [prompt] , generator=lowercase_ , guidance_scale=6.0 , num_inference_steps=2 , output_type='''np''' , image=lowercase_ , ) SCREAMING_SNAKE_CASE_ : int = output.images SCREAMING_SNAKE_CASE_ : Tuple = torch.Generator(device=lowercase_).manual_seed(0) SCREAMING_SNAKE_CASE_ : Optional[Any] = alt_pipe( [prompt] , generator=lowercase_ , guidance_scale=6.0 , num_inference_steps=2 , output_type='''np''' , image=lowercase_ , return_dict=lowercase_ , )[0] SCREAMING_SNAKE_CASE_ : Union[str, Any] = image[0, -3:, -3:, -1] SCREAMING_SNAKE_CASE_ : int = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 32, 32, 3) SCREAMING_SNAKE_CASE_ : Tuple = np.array([0.44_27, 0.37_31, 0.42_49, 0.49_41, 0.45_46, 0.41_48, 0.41_93, 0.46_66, 0.44_99]) assert np.abs(image_slice.flatten() - expected_slice).max() < 5e-3 assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 5e-3 @unittest.skipIf(torch_device != '''cuda''' , '''This test requires a GPU''') def _SCREAMING_SNAKE_CASE ( self : str): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = self.dummy_cond_unet SCREAMING_SNAKE_CASE_ : Optional[int] = PNDMScheduler(skip_prk_steps=lowercase_) SCREAMING_SNAKE_CASE_ : Tuple = self.dummy_vae SCREAMING_SNAKE_CASE_ : Optional[int] = self.dummy_text_encoder SCREAMING_SNAKE_CASE_ : Union[str, Any] = XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta''') SCREAMING_SNAKE_CASE_ : List[Any] = 77 SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.dummy_image.to(lowercase_) # put models in fp16 SCREAMING_SNAKE_CASE_ : str = unet.half() SCREAMING_SNAKE_CASE_ : Any = vae.half() SCREAMING_SNAKE_CASE_ : Dict = bert.half() # make sure here that pndm scheduler skips prk SCREAMING_SNAKE_CASE_ : str = AltDiffusionImgaImgPipeline( unet=lowercase_ , scheduler=lowercase_ , vae=lowercase_ , text_encoder=lowercase_ , tokenizer=lowercase_ , safety_checker=lowercase_ , feature_extractor=self.dummy_extractor , ) SCREAMING_SNAKE_CASE_ : Tuple = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor , do_normalize=lowercase_) SCREAMING_SNAKE_CASE_ : List[Any] = alt_pipe.to(lowercase_) alt_pipe.set_progress_bar_config(disable=lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = '''A painting of a squirrel eating a burger''' SCREAMING_SNAKE_CASE_ : Dict = torch.manual_seed(0) SCREAMING_SNAKE_CASE_ : Any = alt_pipe( [prompt] , generator=lowercase_ , num_inference_steps=2 , output_type='''np''' , image=lowercase_ , ).images assert image.shape == (1, 32, 32, 3) @unittest.skipIf(torch_device != '''cuda''' , '''This test requires a GPU''') def _SCREAMING_SNAKE_CASE ( self : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = load_image( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/img2img/sketch-mountains-input.jpg''') # resize to resolution that is divisible by 8 but not 16 or 32 SCREAMING_SNAKE_CASE_ : Optional[Any] = init_image.resize((760, 504)) SCREAMING_SNAKE_CASE_ : Tuple = '''BAAI/AltDiffusion''' SCREAMING_SNAKE_CASE_ : Any = AltDiffusionImgaImgPipeline.from_pretrained( lowercase_ , safety_checker=lowercase_ , ) pipe.to(lowercase_) pipe.set_progress_bar_config(disable=lowercase_) pipe.enable_attention_slicing() SCREAMING_SNAKE_CASE_ : int = '''A fantasy landscape, trending on artstation''' SCREAMING_SNAKE_CASE_ : Tuple = torch.manual_seed(0) SCREAMING_SNAKE_CASE_ : Any = pipe( prompt=lowercase_ , image=lowercase_ , strength=0.75 , guidance_scale=7.5 , generator=lowercase_ , output_type='''np''' , ) SCREAMING_SNAKE_CASE_ : Tuple = output.images[0] SCREAMING_SNAKE_CASE_ : Optional[int] = image[255:258, 383:386, -1] assert image.shape == (504, 760, 3) SCREAMING_SNAKE_CASE_ : Optional[Any] = np.array([0.93_58, 0.93_97, 0.95_99, 0.99_01, 1.00_00, 1.00_00, 0.98_82, 1.00_00, 1.00_00]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2 @slow @require_torch_gpu class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' super().tearDown() gc.collect() torch.cuda.empty_cache() def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[int] = load_image( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/img2img/sketch-mountains-input.jpg''') SCREAMING_SNAKE_CASE_ : List[str] = init_image.resize((768, 512)) SCREAMING_SNAKE_CASE_ : int = load_numpy( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy''') SCREAMING_SNAKE_CASE_ : Optional[Any] = '''BAAI/AltDiffusion''' SCREAMING_SNAKE_CASE_ : Any = AltDiffusionImgaImgPipeline.from_pretrained( lowercase_ , safety_checker=lowercase_ , ) pipe.to(lowercase_) pipe.set_progress_bar_config(disable=lowercase_) pipe.enable_attention_slicing() SCREAMING_SNAKE_CASE_ : str = '''A fantasy landscape, trending on artstation''' SCREAMING_SNAKE_CASE_ : Optional[Any] = torch.manual_seed(0) SCREAMING_SNAKE_CASE_ : List[Any] = pipe( prompt=lowercase_ , image=lowercase_ , strength=0.75 , guidance_scale=7.5 , generator=lowercase_ , output_type='''np''' , ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = output.images[0] assert image.shape == (512, 768, 3) # img2img is flaky across GPUs even in fp32, so using MAE here assert np.abs(expected_image - image).max() < 1e-2
353
"""simple docstring""" from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCAmelCase_ : Dict = logging.get_logger(__name__) UpperCAmelCase_ : List[str] = { """RWKV/rwkv-4-169m-pile""": """https://huggingface.co/RWKV/rwkv-4-169m-pile/resolve/main/config.json""", """RWKV/rwkv-4-430m-pile""": """https://huggingface.co/RWKV/rwkv-4-430m-pile/resolve/main/config.json""", """RWKV/rwkv-4-1b5-pile""": """https://huggingface.co/RWKV/rwkv-4-1b5-pile/resolve/main/config.json""", """RWKV/rwkv-4-3b-pile""": """https://huggingface.co/RWKV/rwkv-4-3b-pile/resolve/main/config.json""", """RWKV/rwkv-4-7b-pile""": """https://huggingface.co/RWKV/rwkv-4-7b-pile/resolve/main/config.json""", """RWKV/rwkv-4-14b-pile""": """https://huggingface.co/RWKV/rwkv-4-14b-pile/resolve/main/config.json""", """RWKV/rwkv-raven-1b5""": """https://huggingface.co/RWKV/rwkv-raven-1b5/resolve/main/config.json""", """RWKV/rwkv-raven-3b""": """https://huggingface.co/RWKV/rwkv-raven-3b/resolve/main/config.json""", """RWKV/rwkv-raven-7b""": """https://huggingface.co/RWKV/rwkv-raven-7b/resolve/main/config.json""", """RWKV/rwkv-raven-14b""": """https://huggingface.co/RWKV/rwkv-raven-14b/resolve/main/config.json""", } class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = "rwkv" __UpperCamelCase = {"max_position_embeddings": "context_length"} def __init__( self : Union[str, Any] , lowercase_ : Any=50277 , lowercase_ : str=1024 , lowercase_ : List[str]=4096 , lowercase_ : Optional[Any]=32 , lowercase_ : Any=None , lowercase_ : Any=None , lowercase_ : List[Any]=1e-5 , lowercase_ : Union[str, Any]=0 , lowercase_ : Union[str, Any]=0 , lowercase_ : int=6 , lowercase_ : Tuple=False , lowercase_ : Any=True , **lowercase_ : Any , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Union[str, Any] = vocab_size SCREAMING_SNAKE_CASE_ : Any = context_length SCREAMING_SNAKE_CASE_ : int = hidden_size SCREAMING_SNAKE_CASE_ : int = num_hidden_layers SCREAMING_SNAKE_CASE_ : List[str] = attention_hidden_size if attention_hidden_size is not None else hidden_size SCREAMING_SNAKE_CASE_ : int = intermediate_size if intermediate_size is not None else 4 * hidden_size SCREAMING_SNAKE_CASE_ : int = layer_norm_epsilon SCREAMING_SNAKE_CASE_ : Optional[int] = rescale_every SCREAMING_SNAKE_CASE_ : Dict = use_cache SCREAMING_SNAKE_CASE_ : Dict = bos_token_id SCREAMING_SNAKE_CASE_ : Any = eos_token_id super().__init__( tie_word_embeddings=lowercase_ , bos_token_id=lowercase_ , eos_token_id=lowercase_ , **lowercase_)
318
0
"""simple docstring""" import logging import os from dataclasses import dataclass, field from typing import Dict, Optional import datasets import numpy as np import tensorflow as tf from transformers import ( AutoConfig, AutoTokenizer, EvalPrediction, HfArgumentParser, PreTrainedTokenizer, TFAutoModelForSequenceClassification, TFTrainer, TFTrainingArguments, ) from transformers.utils import logging as hf_logging hf_logging.set_verbosity_info() hf_logging.enable_default_handler() hf_logging.enable_explicit_format() def _A (__a , __a , __a , __a , __a , __a = None , ) -> Any: """simple docstring""" SCREAMING_SNAKE_CASE_ : Dict = {} if train_file is not None: SCREAMING_SNAKE_CASE_ : Optional[int] = [train_file] if eval_file is not None: SCREAMING_SNAKE_CASE_ : Optional[Any] = [eval_file] if test_file is not None: SCREAMING_SNAKE_CASE_ : Dict = [test_file] SCREAMING_SNAKE_CASE_ : List[Any] = datasets.load_dataset('''csv''' , data_files=__a ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = list(ds[list(files.keys() )[0]].features.keys() ) SCREAMING_SNAKE_CASE_ : int = features_name.pop(__a ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = list(set(ds[list(files.keys() )[0]][label_name] ) ) SCREAMING_SNAKE_CASE_ : List[Any] = {label: i for i, label in enumerate(__a )} SCREAMING_SNAKE_CASE_ : Dict = tokenizer.model_input_names SCREAMING_SNAKE_CASE_ : Any = {} if len(__a ) == 1: for k in files.keys(): SCREAMING_SNAKE_CASE_ : Union[str, Any] = ds[k].map( lambda __a : tokenizer.batch_encode_plus( example[features_name[0]] , truncation=__a , max_length=__a , padding='''max_length''' ) , batched=__a , ) elif len(__a ) == 2: for k in files.keys(): SCREAMING_SNAKE_CASE_ : Dict = ds[k].map( lambda __a : tokenizer.batch_encode_plus( (example[features_name[0]], example[features_name[1]]) , truncation=__a , max_length=__a , padding='''max_length''' , ) , batched=__a , ) def gen_train(): for ex in transformed_ds[datasets.Split.TRAIN]: SCREAMING_SNAKE_CASE_ : Union[str, Any] = {k: v for k, v in ex.items() if k in input_names} SCREAMING_SNAKE_CASE_ : Union[str, Any] = labelaid[ex[label_name]] yield (d, label) def gen_val(): for ex in transformed_ds[datasets.Split.VALIDATION]: SCREAMING_SNAKE_CASE_ : Optional[Any] = {k: v for k, v in ex.items() if k in input_names} SCREAMING_SNAKE_CASE_ : Any = labelaid[ex[label_name]] yield (d, label) def gen_test(): for ex in transformed_ds[datasets.Split.TEST]: SCREAMING_SNAKE_CASE_ : Any = {k: v for k, v in ex.items() if k in input_names} SCREAMING_SNAKE_CASE_ : Any = labelaid[ex[label_name]] yield (d, label) SCREAMING_SNAKE_CASE_ : Any = ( tf.data.Dataset.from_generator( __a , ({k: tf.intaa for k in input_names}, tf.intaa) , ({k: tf.TensorShape([None] ) for k in input_names}, tf.TensorShape([] )) , ) if datasets.Split.TRAIN in transformed_ds else None ) if train_ds is not None: SCREAMING_SNAKE_CASE_ : List[Any] = train_ds.apply(tf.data.experimental.assert_cardinality(len(ds[datasets.Split.TRAIN] ) ) ) SCREAMING_SNAKE_CASE_ : List[str] = ( tf.data.Dataset.from_generator( __a , ({k: tf.intaa for k in input_names}, tf.intaa) , ({k: tf.TensorShape([None] ) for k in input_names}, tf.TensorShape([] )) , ) if datasets.Split.VALIDATION in transformed_ds else None ) if val_ds is not None: SCREAMING_SNAKE_CASE_ : int = val_ds.apply(tf.data.experimental.assert_cardinality(len(ds[datasets.Split.VALIDATION] ) ) ) SCREAMING_SNAKE_CASE_ : int = ( tf.data.Dataset.from_generator( __a , ({k: tf.intaa for k in input_names}, tf.intaa) , ({k: tf.TensorShape([None] ) for k in input_names}, tf.TensorShape([] )) , ) if datasets.Split.TEST in transformed_ds else None ) if test_ds is not None: SCREAMING_SNAKE_CASE_ : Union[str, Any] = test_ds.apply(tf.data.experimental.assert_cardinality(len(ds[datasets.Split.TEST] ) ) ) return train_ds, val_ds, test_ds, labelaid UpperCAmelCase_ = logging.getLogger(__name__) @dataclass class lowerCAmelCase__ : '''simple docstring''' __UpperCamelCase = field(metadata={"help": "Which column contains the label"} ) __UpperCamelCase = field(default=UpperCAmelCase__ , metadata={"help": "The path of the training file"} ) __UpperCamelCase = field(default=UpperCAmelCase__ , metadata={"help": "The path of the development file"} ) __UpperCamelCase = field(default=UpperCAmelCase__ , metadata={"help": "The path of the test file"} ) __UpperCamelCase = field( default=1_2_8 , metadata={ "help": ( "The maximum total input sequence length after tokenization. Sequences longer " "than this will be truncated, sequences shorter will be padded." ) } , ) __UpperCamelCase = field( default=UpperCAmelCase__ , metadata={"help": "Overwrite the cached training and evaluation sets"} ) @dataclass class lowerCAmelCase__ : '''simple docstring''' __UpperCamelCase = field( metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"} ) __UpperCamelCase = field( default=UpperCAmelCase__ , metadata={"help": "Pretrained config name or path if not the same as model_name"} ) __UpperCamelCase = field( default=UpperCAmelCase__ , metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"} ) __UpperCamelCase = field(default=UpperCAmelCase__ , metadata={"help": "Set this flag to use fast tokenization."} ) # If you want to tweak more attributes on your tokenizer, you should do it in a distinct script, # or just modify its tokenizer_config.json. __UpperCamelCase = field( default=UpperCAmelCase__ , metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"} , ) def _A () -> Union[str, Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[int] = HfArgumentParser((ModelArguments, DataTrainingArguments, TFTrainingArguments) ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = parser.parse_args_into_dataclasses() if ( os.path.exists(training_args.output_dir ) and os.listdir(training_args.output_dir ) and training_args.do_train and not training_args.overwrite_output_dir ): raise ValueError( f'Output directory ({training_args.output_dir}) already exists and is not empty. Use' ''' --overwrite_output_dir to overcome.''' ) # Setup logging logging.basicConfig( format='''%(asctime)s - %(levelname)s - %(name)s - %(message)s''' , datefmt='''%m/%d/%Y %H:%M:%S''' , level=logging.INFO , ) logger.info( f'n_replicas: {training_args.n_replicas}, distributed training: {bool(training_args.n_replicas > 1 )}, ' f'16-bits training: {training_args.fpaa}' ) logger.info(f'Training/evaluation parameters {training_args}' ) # Load pretrained model and tokenizer # # Distributed training: # The .from_pretrained methods guarantee that only one local process can concurrently # download model & vocab. SCREAMING_SNAKE_CASE_ : Dict = AutoTokenizer.from_pretrained( model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path , cache_dir=model_args.cache_dir , ) SCREAMING_SNAKE_CASE_ : Tuple = get_tfds( train_file=data_args.train_file , eval_file=data_args.dev_file , test_file=data_args.test_file , tokenizer=__a , label_column_id=data_args.label_column_id , max_seq_length=data_args.max_seq_length , ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = AutoConfig.from_pretrained( model_args.config_name if model_args.config_name else model_args.model_name_or_path , num_labels=len(__a ) , labelaid=__a , idalabel={id: label for label, id in labelaid.items()} , finetuning_task='''text-classification''' , cache_dir=model_args.cache_dir , ) with training_args.strategy.scope(): SCREAMING_SNAKE_CASE_ : Optional[Any] = TFAutoModelForSequenceClassification.from_pretrained( model_args.model_name_or_path , from_pt=bool('''.bin''' in model_args.model_name_or_path ) , config=__a , cache_dir=model_args.cache_dir , ) def compute_metrics(__a ) -> Dict: SCREAMING_SNAKE_CASE_ : Any = np.argmax(p.predictions , axis=1 ) return {"acc": (preds == p.label_ids).mean()} # Initialize our Trainer SCREAMING_SNAKE_CASE_ : Optional[Any] = TFTrainer( model=__a , args=__a , train_dataset=__a , eval_dataset=__a , compute_metrics=__a , ) # Training if training_args.do_train: trainer.train() trainer.save_model() tokenizer.save_pretrained(training_args.output_dir ) # Evaluation SCREAMING_SNAKE_CASE_ : Optional[Any] = {} if training_args.do_eval: logger.info('''*** Evaluate ***''' ) SCREAMING_SNAKE_CASE_ : Dict = trainer.evaluate() SCREAMING_SNAKE_CASE_ : Optional[Any] = os.path.join(training_args.output_dir , '''eval_results.txt''' ) with open(__a , '''w''' ) as writer: logger.info('''***** Eval results *****''' ) for key, value in result.items(): logger.info(f' {key} = {value}' ) writer.write(f'{key} = {value}\n' ) results.update(__a ) return results if __name__ == "__main__": main()
354
"""simple docstring""" UpperCAmelCase_ : Optional[int] = 8.3_1_4_4_5_9_8 def _A (__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 UpperCAmelCase_ : str = 300 UpperCAmelCase_ : str = 28 UpperCAmelCase_ : Any = rms_speed_of_molecule(temperature, molar_mass) print(f'''Vrms of Nitrogen gas at 300 K is {vrms} m/s''')
318
0
"""simple docstring""" from datetime import datetime import requests from bsa import BeautifulSoup if __name__ == "__main__": UpperCAmelCase_ : List[str] = input("""Enter image url: """).strip() print(f'''Downloading image from {url} ...''') UpperCAmelCase_ : List[Any] = BeautifulSoup(requests.get(url).content, """html.parser""") # The image URL is in the content field of the first meta tag with property og:image UpperCAmelCase_ : List[str] = soup.find("""meta""", {"""property""": """og:image"""})["""content"""] UpperCAmelCase_ : Dict = requests.get(image_url).content UpperCAmelCase_ : List[Any] = f'''{datetime.now():%Y-%m-%d_%H:%M:%S}.jpg''' with open(file_name, """wb""") as fp: fp.write(image_data) print(f'''Done. Image saved to disk as {file_name}.''')
355
"""simple docstring""" import json import multiprocessing import os import re from collections import defaultdict import torch from accelerate import Accelerator from accelerate.utils import set_seed from arguments import HumanEvalArguments from datasets import load_dataset, load_metric from torch.utils.data import IterableDataset from torch.utils.data.dataloader import DataLoader from tqdm import tqdm import transformers from transformers import AutoModelForCausalLM, AutoTokenizer, HfArgumentParser, StoppingCriteria, StoppingCriteriaList UpperCAmelCase_ : Union[str, Any] = ["""\nclass""", """\ndef""", """\n#""", """\n@""", """\nprint""", """\nif"""] class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def __init__( self : List[Any] , lowercase_ : Tuple , lowercase_ : Optional[int] , lowercase_ : int=None , lowercase_ : Dict=1): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = tokenizer SCREAMING_SNAKE_CASE_ : Optional[int] = dataset SCREAMING_SNAKE_CASE_ : Optional[Any] = len(lowercase_) if n_tasks is None else n_tasks SCREAMING_SNAKE_CASE_ : Optional[int] = n_copies def __iter__( self : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = [] for task in range(self.n_tasks): # without strip, the model generate commented codes ... prompts.append(self.tokenizer.eos_token + self.dataset[task]['''prompt'''].strip()) SCREAMING_SNAKE_CASE_ : Optional[Any] = self.tokenizer(lowercase_ , padding=lowercase_ , return_tensors='''pt''') for task in range(self.n_tasks): for _ in range(self.n_copies): yield { "ids": outputs.input_ids[task], "task_id": task, "input_len": outputs.attention_mask[task].sum(), } class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def __init__( self : int , lowercase_ : Dict , lowercase_ : Optional[Any] , lowercase_ : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = start_length SCREAMING_SNAKE_CASE_ : List[Any] = eof_strings SCREAMING_SNAKE_CASE_ : List[Any] = tokenizer def __call__( self : Optional[int] , lowercase_ : Any , lowercase_ : int , **lowercase_ : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : str = self.tokenizer.batch_decode(input_ids[:, self.start_length :]) SCREAMING_SNAKE_CASE_ : Tuple = [] for decoded_generation in decoded_generations: done.append(any(stop_string in decoded_generation for stop_string in self.eof_strings)) return all(lowercase_) def _A (__a ) -> Union[str, Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Dict = re.split('''(%s)''' % '''|'''.join(__a ) , __a ) # last string should be "" return "".join(string_list[:-2] ) def _A (__a , __a , __a , __a , __a , __a=20 , **__a ) -> List[str]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Tuple = defaultdict(__a ) # dict of list of generated tokens for step, batch in tqdm(enumerate(__a ) ): with torch.no_grad(): SCREAMING_SNAKE_CASE_ : Optional[int] = batch['''ids'''].shape[-1] SCREAMING_SNAKE_CASE_ : Tuple = accelerator.unwrap_model(__a ).generate( input_ids=batch['''ids'''][:, : batch['''input_len''']] , num_return_sequences=__a , **__a ) # each task is generated batch_size times SCREAMING_SNAKE_CASE_ : List[Any] = batch['''task_id'''].repeat(__a ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = accelerator.pad_across_processes( __a , dim=1 , pad_index=tokenizer.pad_token_id ) SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Union[str, Any] = accelerator.gather((generated_tokens, generated_tasks) ) SCREAMING_SNAKE_CASE_ : int = generated_tokens.cpu().numpy() SCREAMING_SNAKE_CASE_ : Optional[Any] = generated_tasks.cpu().numpy() for task, generated_tokens in zip(__a , __a ): gen_token_dict[task].append(__a ) SCREAMING_SNAKE_CASE_ : int = [[] for _ in range(__a )] for task, generated_tokens in gen_token_dict.items(): for s in generated_tokens: SCREAMING_SNAKE_CASE_ : Optional[int] = tokenizer.decode(__a , skip_special_tokens=__a , clean_up_tokenization_spaces=__a ) code_gens[task].append(remove_last_block(__a ) ) return code_gens def _A () -> Optional[int]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Union[str, Any] = HfArgumentParser(__a ) SCREAMING_SNAKE_CASE_ : List[Any] = parser.parse_args() transformers.logging.set_verbosity_error() # enables code execution in code_eval metric SCREAMING_SNAKE_CASE_ : Any = args.HF_ALLOW_CODE_EVAL # make sure tokenizer plays nice with multiprocessing SCREAMING_SNAKE_CASE_ : str = '''false''' if args.num_workers is None: SCREAMING_SNAKE_CASE_ : Optional[Any] = multiprocessing.cpu_count() # Use dataset load to feed to accelerate SCREAMING_SNAKE_CASE_ : Tuple = Accelerator() set_seed(args.seed , device_specific=__a ) # Load model and tokenizer SCREAMING_SNAKE_CASE_ : Dict = AutoTokenizer.from_pretrained(args.model_ckpt ) SCREAMING_SNAKE_CASE_ : Dict = tokenizer.eos_token SCREAMING_SNAKE_CASE_ : Optional[int] = AutoModelForCausalLM.from_pretrained(args.model_ckpt ) # Generation settings SCREAMING_SNAKE_CASE_ : List[str] = { '''do_sample''': args.do_sample, '''temperature''': args.temperature, '''max_new_tokens''': args.max_new_tokens, '''top_p''': args.top_p, '''top_k''': args.top_k, '''stopping_criteria''': StoppingCriteriaList([EndOfFunctionCriteria(0 , __a , __a )] ), } # Load evaluation dataset and metric SCREAMING_SNAKE_CASE_ : Optional[int] = load_dataset('''openai_humaneval''' ) SCREAMING_SNAKE_CASE_ : str = load_metric('''code_eval''' ) SCREAMING_SNAKE_CASE_ : int = args.num_tasks if args.num_tasks is not None else len(human_eval['''test'''] ) SCREAMING_SNAKE_CASE_ : List[str] = args.n_samples // args.batch_size SCREAMING_SNAKE_CASE_ : Union[str, Any] = TokenizedDataset(__a , human_eval['''test'''] , n_copies=__a , n_tasks=__a ) # do not confuse args.batch_size, which is actually the num_return_sequences SCREAMING_SNAKE_CASE_ : Optional[int] = DataLoader(__a , batch_size=1 ) # Run a quick test to see if code evaluation is enabled try: SCREAMING_SNAKE_CASE_ : Any = code_eval_metric.compute(references=[''''''] , predictions=[['''''']] ) except ValueError as exception: print( '''Code evaluation not enabled. Read the warning below carefully and then use `--HF_ALLOW_CODE_EVAL="1"`''' ''' flag to enable code evaluation.''' ) raise exception SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : int = accelerator.prepare(__a , __a ) SCREAMING_SNAKE_CASE_ : List[Any] = complete_code( __a , __a , __a , __a , n_tasks=__a , batch_size=args.batch_size , **__a , ) if accelerator.is_main_process: SCREAMING_SNAKE_CASE_ : int = [] for task in tqdm(range(__a ) ): SCREAMING_SNAKE_CASE_ : Tuple = human_eval['''test'''][task]['''test'''] SCREAMING_SNAKE_CASE_ : Tuple = f'check({human_eval["test"][task]["entry_point"]})' references.append('''\n''' + test_func + '''\n''' + entry_point ) # Evaluate completions with "code_eval" metric SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Dict = code_eval_metric.compute( references=__a , predictions=__a , num_workers=args.num_workers ) print(f'Results: {pass_at_k}' ) # Save results to json file with open(args.output_file , '''w''' ) as fp: json.dump(__a , __a ) # For some reason the folliwng seems to be necessary sometimes for code_eval to work nice with multiprocessing # https://stackoverflow.com/questions/60804599/python-multiprocessing-keeps-spawning-the-whole-script if __name__ == "__main__": main()
318
0
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_tokenizers_available, is_torch_available, ) UpperCAmelCase_ : Union[str, 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: UpperCAmelCase_ : int = ["""BlenderbotTokenizerFast"""] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase_ : str = [ """BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST""", """BlenderbotForCausalLM""", """BlenderbotForConditionalGeneration""", """BlenderbotModel""", """BlenderbotPreTrainedModel""", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase_ : str = [ """TFBlenderbotForConditionalGeneration""", """TFBlenderbotModel""", """TFBlenderbotPreTrainedModel""", ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase_ : Dict = [ """FlaxBlenderbotForConditionalGeneration""", """FlaxBlenderbotModel""", """FlaxBlenderbotPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_blenderbot import ( BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP, BlenderbotConfig, BlenderbotOnnxConfig, ) from .tokenization_blenderbot import BlenderbotTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_blenderbot_fast import BlenderbotTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_blenderbot import ( BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST, BlenderbotForCausalLM, BlenderbotForConditionalGeneration, BlenderbotModel, BlenderbotPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_blenderbot import ( TFBlenderbotForConditionalGeneration, TFBlenderbotModel, TFBlenderbotPreTrainedModel, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_blenderbot import ( FlaxBlenderbotForConditionalGeneration, FlaxBlenderbotModel, FlaxBlenderbotPreTrainedModel, ) else: import sys UpperCAmelCase_ : Tuple = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
356
"""simple docstring""" from ...processing_utils import ProcessorMixin class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = ["image_processor", "feature_extractor"] __UpperCamelCase = "TvltImageProcessor" __UpperCamelCase = "TvltFeatureExtractor" def __init__( self : int , lowercase_ : Optional[Any] , lowercase_ : Optional[Any]): '''simple docstring''' super().__init__(image_processor=lowercase_ , feature_extractor=lowercase_) SCREAMING_SNAKE_CASE_ : Union[str, Any] = image_processor SCREAMING_SNAKE_CASE_ : Optional[Any] = feature_extractor def __call__( self : Any , lowercase_ : str=None , lowercase_ : Optional[Any]=None , lowercase_ : Optional[Any]=None , lowercase_ : str=None , lowercase_ : int=False , lowercase_ : Union[str, Any]=False , *lowercase_ : List[Any] , **lowercase_ : List[str] , ): '''simple docstring''' if images is None and audio is None: raise ValueError('''You need to specify either an `images` or `audio` input to process.''') SCREAMING_SNAKE_CASE_ : Any = None if images is not None: SCREAMING_SNAKE_CASE_ : Tuple = self.image_processor(lowercase_ , mask_pixel=lowercase_ , *lowercase_ , **lowercase_) if images_mixed is not None: SCREAMING_SNAKE_CASE_ : Optional[int] = self.image_processor(lowercase_ , is_mixed=lowercase_ , *lowercase_ , **lowercase_) if audio is not None: SCREAMING_SNAKE_CASE_ : Any = self.feature_extractor( lowercase_ , *lowercase_ , sampling_rate=lowercase_ , mask_audio=lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : List[Any] = {} if audio is not None: output_dict.update(lowercase_) if images is not None: output_dict.update(lowercase_) if images_mixed_dict is not None: output_dict.update(lowercase_) return output_dict @property def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Optional[Any] = self.image_processor.model_input_names SCREAMING_SNAKE_CASE_ : Dict = self.feature_extractor.model_input_names return list(dict.fromkeys(image_processor_input_names + feature_extractor_input_names))
318
0
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available UpperCAmelCase_ : Tuple = {} try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase_ : List[str] = ["""MLukeTokenizer"""] if TYPE_CHECKING: try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_mluke import MLukeTokenizer else: import sys UpperCAmelCase_ : List[str] = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
357
"""simple docstring""" from ...processing_utils import ProcessorMixin class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' __UpperCamelCase = "SpeechT5FeatureExtractor" __UpperCamelCase = "SpeechT5Tokenizer" def __init__( self : Any , lowercase_ : Dict , lowercase_ : Optional[Any]): '''simple docstring''' super().__init__(lowercase_ , lowercase_) def __call__( self : List[Any] , *lowercase_ : List[Any] , **lowercase_ : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[str] = kwargs.pop('''audio''' , lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = kwargs.pop('''text''' , lowercase_) SCREAMING_SNAKE_CASE_ : Any = kwargs.pop('''text_target''' , lowercase_) SCREAMING_SNAKE_CASE_ : Dict = kwargs.pop('''audio_target''' , lowercase_) SCREAMING_SNAKE_CASE_ : List[Any] = kwargs.pop('''sampling_rate''' , lowercase_) if audio is not None and text is not None: raise ValueError( '''Cannot process both `audio` and `text` inputs. Did you mean `audio_target` or `text_target`?''') if audio_target is not None and text_target is not None: raise ValueError( '''Cannot process both `audio_target` and `text_target` inputs. Did you mean `audio` or `text`?''') if audio is None and audio_target is None and text is None and text_target is None: raise ValueError( '''You need to specify either an `audio`, `audio_target`, `text`, or `text_target` input to process.''') if audio is not None: SCREAMING_SNAKE_CASE_ : Any = self.feature_extractor(lowercase_ , *lowercase_ , sampling_rate=lowercase_ , **lowercase_) elif text is not None: SCREAMING_SNAKE_CASE_ : Dict = self.tokenizer(lowercase_ , **lowercase_) else: SCREAMING_SNAKE_CASE_ : Any = None if audio_target is not None: SCREAMING_SNAKE_CASE_ : List[Any] = self.feature_extractor(audio_target=lowercase_ , *lowercase_ , sampling_rate=lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : Optional[int] = targets['''input_values'''] elif text_target is not None: SCREAMING_SNAKE_CASE_ : int = self.tokenizer(lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : List[Any] = targets['''input_ids'''] else: SCREAMING_SNAKE_CASE_ : int = None if inputs is None: return targets if targets is not None: SCREAMING_SNAKE_CASE_ : Union[str, Any] = labels SCREAMING_SNAKE_CASE_ : Optional[Any] = targets.get('''attention_mask''') if decoder_attention_mask is not None: SCREAMING_SNAKE_CASE_ : Any = decoder_attention_mask return inputs def _SCREAMING_SNAKE_CASE ( self : Tuple , *lowercase_ : Tuple , **lowercase_ : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = kwargs.pop('''input_values''' , lowercase_) SCREAMING_SNAKE_CASE_ : int = kwargs.pop('''input_ids''' , lowercase_) SCREAMING_SNAKE_CASE_ : Dict = kwargs.pop('''labels''' , lowercase_) if input_values is not None and input_ids is not None: raise ValueError('''Cannot process both `input_values` and `input_ids` inputs.''') if input_values is None and input_ids is None and labels is None: raise ValueError( '''You need to specify either an `input_values`, `input_ids`, or `labels` input to be padded.''') if input_values is not None: SCREAMING_SNAKE_CASE_ : Any = self.feature_extractor.pad(lowercase_ , *lowercase_ , **lowercase_) elif input_ids is not None: SCREAMING_SNAKE_CASE_ : Tuple = self.tokenizer.pad(lowercase_ , **lowercase_) else: SCREAMING_SNAKE_CASE_ : List[Any] = None if labels is not None: if "input_ids" in labels or (isinstance(lowercase_ , lowercase_) and "input_ids" in labels[0]): SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.tokenizer.pad(lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : Dict = targets['''input_ids'''] else: SCREAMING_SNAKE_CASE_ : Dict = self.feature_extractor.feature_size SCREAMING_SNAKE_CASE_ : Optional[int] = self.feature_extractor.num_mel_bins SCREAMING_SNAKE_CASE_ : str = self.feature_extractor.pad(lowercase_ , *lowercase_ , **lowercase_) SCREAMING_SNAKE_CASE_ : str = feature_size_hack SCREAMING_SNAKE_CASE_ : Dict = targets['''input_values'''] else: SCREAMING_SNAKE_CASE_ : List[Any] = None if inputs is None: return targets if targets is not None: SCREAMING_SNAKE_CASE_ : Dict = labels SCREAMING_SNAKE_CASE_ : List[str] = targets.get('''attention_mask''') if decoder_attention_mask is not None: SCREAMING_SNAKE_CASE_ : Optional[Any] = decoder_attention_mask return inputs def _SCREAMING_SNAKE_CASE ( self : Optional[Any] , *lowercase_ : Optional[int] , **lowercase_ : Tuple): '''simple docstring''' return self.tokenizer.batch_decode(*lowercase_ , **lowercase_) def _SCREAMING_SNAKE_CASE ( self : List[Any] , *lowercase_ : Dict , **lowercase_ : List[Any]): '''simple docstring''' return self.tokenizer.decode(*lowercase_ , **lowercase_)
318
0
"""simple docstring""" from collections import defaultdict from pathlib import Path import pandas as pd from rouge_cli import calculate_rouge_path from utils import calculate_rouge UpperCAmelCase_ : str = [ """Prosecutor: \"No videos were used in the crash investigation\" German papers say they saw a cell phone video of the""" """ final seconds on board Flight 9525. The Germanwings co-pilot says he had a \"previous episode of severe""" """ depression\" German airline confirms it knew of Andreas Lubitz's depression years before he took control.""", """The Palestinian Authority officially becomes the 123rd member of the International Criminal Court. The formal""" """ accession was marked with a ceremony at The Hague, in the Netherlands. The Palestinians signed the ICC's""" """ founding Rome Statute in January. Israel and the United States opposed the Palestinians' efforts to join the""" """ body.""", """Amnesty International releases its annual report on the death penalty. The report catalogs the use of""" """ state-sanctioned killing as a punitive measure across the globe. At least 607 people were executed around the""" """ world in 2014, compared to 778 in 2013. The U.S. remains one of the worst offenders for imposing capital""" """ punishment.""", ] UpperCAmelCase_ : Union[str, Any] = [ """Marseille prosecutor says \"so far no videos were used in the crash investigation\" despite media reports .""" """ Journalists at Bild and Paris Match are \"very confident\" the video clip is real, an editor says . Andreas Lubitz""" """ had informed his Lufthansa training school of an episode of severe depression, airline says .""", """Membership gives the ICC jurisdiction over alleged crimes committed in Palestinian territories since last June .""" """ Israel and the United States opposed the move, which could open the door to war crimes investigations against""" """ Israelis .""", """Amnesty's annual death penalty report catalogs encouraging signs, but setbacks in numbers of those sentenced to""" """ death . Organization claims that governments around the world are using the threat of terrorism to advance""" """ executions . The number of executions worldwide has gone down by almost 22% compared with 2013, but death""" """ sentences up by 28% .""", ] def _A () -> List[Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : List[str] = calculate_rouge(__a , __a , bootstrap_aggregation=__a , rouge_keys=['''rouge2''', '''rougeL'''] ) assert isinstance(__a , __a ) SCREAMING_SNAKE_CASE_ : Optional[Any] = calculate_rouge(__a , __a , bootstrap_aggregation=__a , rouge_keys=['''rouge2'''] ) assert ( pd.DataFrame(no_aggregation['''rouge2'''] ).fmeasure.mean() == pd.DataFrame(no_aggregation_just_ra['''rouge2'''] ).fmeasure.mean() ) def _A () -> Union[str, Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : List[Any] = '''rougeLsum''' SCREAMING_SNAKE_CASE_ : Tuple = calculate_rouge(__a , __a , newline_sep=__a , rouge_keys=[k] )[k] SCREAMING_SNAKE_CASE_ : Optional[int] = calculate_rouge(__a , __a , newline_sep=__a , rouge_keys=[k] )[k] assert score > score_no_sep def _A () -> Optional[Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : List[str] = ['''rouge1''', '''rouge2''', '''rougeL'''] SCREAMING_SNAKE_CASE_ : str = calculate_rouge(__a , __a , newline_sep=__a , rouge_keys=__a ) SCREAMING_SNAKE_CASE_ : str = calculate_rouge(__a , __a , newline_sep=__a , rouge_keys=__a ) assert score_sep == score_no_sep def _A () -> Optional[Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Dict = [ '''Her older sister, Margot Frank, died in 1945, a month earlier than previously thought.''', '''Marseille prosecutor says "so far no videos were used in the crash investigation" despite media reports .''', ] SCREAMING_SNAKE_CASE_ : Union[str, Any] = [ '''Margot Frank, died in 1945, a month earlier than previously thought.''', '''Prosecutor: "No videos were used in the crash investigation" German papers say they saw a cell phone video of''' ''' the final seconds on board Flight 9525.''', ] assert calculate_rouge(__a , __a , newline_sep=__a ) == calculate_rouge(__a , __a , newline_sep=__a ) def _A () -> Union[str, Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : List[Any] = [ '''" "a person who has such a video needs to immediately give it to the investigators," prosecutor says .<n> "it is a very disturbing scene," editor-in-chief of bild online tells "erin burnett: outfront" ''' ] SCREAMING_SNAKE_CASE_ : str = [ ''' Marseille prosecutor says "so far no videos were used in the crash investigation" despite media reports . Journalists at Bild and Paris Match are "very confident" the video clip is real, an editor says . Andreas Lubitz had informed his Lufthansa training school of an episode of severe depression, airline says .''' ] SCREAMING_SNAKE_CASE_ : List[Any] = calculate_rouge(__a , __a , rouge_keys=['''rougeLsum'''] , newline_sep=__a )['''rougeLsum'''] SCREAMING_SNAKE_CASE_ : int = calculate_rouge(__a , __a , rouge_keys=['''rougeLsum'''] )['''rougeLsum'''] assert new_score > prev_score def _A () -> int: """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[int] = Path('''examples/seq2seq/test_data/wmt_en_ro''' ) SCREAMING_SNAKE_CASE_ : List[str] = calculate_rouge_path(data_dir.joinpath('''test.source''' ) , data_dir.joinpath('''test.target''' ) ) assert isinstance(__a , __a ) SCREAMING_SNAKE_CASE_ : List[str] = calculate_rouge_path( data_dir.joinpath('''test.source''' ) , data_dir.joinpath('''test.target''' ) , bootstrap_aggregation=__a ) assert isinstance(__a , __a )
358
"""simple docstring""" import os from typing import BinaryIO, Optional, Union import numpy as np import pyarrow.parquet as pq from .. import Audio, Dataset, Features, Image, NamedSplit, Value, config from ..features.features import FeatureType, _visit from ..formatting import query_table from ..packaged_modules import _PACKAGED_DATASETS_MODULES from ..packaged_modules.parquet.parquet import Parquet from ..utils import logging from ..utils.typing import NestedDataStructureLike, PathLike from .abc import AbstractDatasetReader def _A (__a ) -> Optional[int]: """simple docstring""" SCREAMING_SNAKE_CASE_ : List[str] = np.inf def set_batch_size(__a ) -> None: nonlocal batch_size if isinstance(__a , __a ): SCREAMING_SNAKE_CASE_ : Tuple = min(__a , config.PARQUET_ROW_GROUP_SIZE_FOR_IMAGE_DATASETS ) elif isinstance(__a , __a ): SCREAMING_SNAKE_CASE_ : int = min(__a , config.PARQUET_ROW_GROUP_SIZE_FOR_AUDIO_DATASETS ) elif isinstance(__a , __a ) and feature.dtype == "binary": SCREAMING_SNAKE_CASE_ : Union[str, Any] = min(__a , config.PARQUET_ROW_GROUP_SIZE_FOR_BINARY_DATASETS ) _visit(__a , __a ) return None if batch_size is np.inf else batch_size class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def __init__( self : Any , lowercase_ : NestedDataStructureLike[PathLike] , lowercase_ : Optional[NamedSplit] = None , lowercase_ : Optional[Features] = None , lowercase_ : str = None , lowercase_ : bool = False , lowercase_ : bool = False , lowercase_ : Optional[int] = None , **lowercase_ : Optional[int] , ): '''simple docstring''' super().__init__( lowercase_ , split=lowercase_ , features=lowercase_ , cache_dir=lowercase_ , keep_in_memory=lowercase_ , streaming=lowercase_ , num_proc=lowercase_ , **lowercase_ , ) SCREAMING_SNAKE_CASE_ : Any = path_or_paths if isinstance(lowercase_ , lowercase_) else {self.split: path_or_paths} SCREAMING_SNAKE_CASE_ : Any = _PACKAGED_DATASETS_MODULES['''parquet'''][1] SCREAMING_SNAKE_CASE_ : Union[str, Any] = Parquet( cache_dir=lowercase_ , data_files=lowercase_ , features=lowercase_ , hash=lowercase_ , **lowercase_ , ) def _SCREAMING_SNAKE_CASE ( self : Tuple): '''simple docstring''' if self.streaming: SCREAMING_SNAKE_CASE_ : str = self.builder.as_streaming_dataset(split=self.split) # Build regular (map-style) dataset else: SCREAMING_SNAKE_CASE_ : Optional[Any] = None SCREAMING_SNAKE_CASE_ : Optional[int] = None SCREAMING_SNAKE_CASE_ : Tuple = None SCREAMING_SNAKE_CASE_ : Dict = None self.builder.download_and_prepare( download_config=lowercase_ , download_mode=lowercase_ , verification_mode=lowercase_ , base_path=lowercase_ , num_proc=self.num_proc , ) SCREAMING_SNAKE_CASE_ : Any = self.builder.as_dataset( split=self.split , verification_mode=lowercase_ , in_memory=self.keep_in_memory) return dataset class lowerCAmelCase__ : '''simple docstring''' def __init__( self : Tuple , lowercase_ : Dataset , lowercase_ : Union[PathLike, BinaryIO] , lowercase_ : Optional[int] = None , **lowercase_ : Dict , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = dataset SCREAMING_SNAKE_CASE_ : Dict = path_or_buf SCREAMING_SNAKE_CASE_ : List[Any] = batch_size or get_writer_batch_size(dataset.features) SCREAMING_SNAKE_CASE_ : Any = parquet_writer_kwargs def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[str] = self.batch_size if self.batch_size else config.DEFAULT_MAX_BATCH_SIZE if isinstance(self.path_or_buf , (str, bytes, os.PathLike)): with open(self.path_or_buf , '''wb+''') as buffer: SCREAMING_SNAKE_CASE_ : Optional[Any] = self._write(file_obj=lowercase_ , batch_size=lowercase_ , **self.parquet_writer_kwargs) else: SCREAMING_SNAKE_CASE_ : str = self._write(file_obj=self.path_or_buf , batch_size=lowercase_ , **self.parquet_writer_kwargs) return written def _SCREAMING_SNAKE_CASE ( self : Tuple , lowercase_ : BinaryIO , lowercase_ : int , **lowercase_ : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = 0 SCREAMING_SNAKE_CASE_ : Optional[int] = parquet_writer_kwargs.pop('''path_or_buf''' , lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = self.dataset.features.arrow_schema SCREAMING_SNAKE_CASE_ : Tuple = pq.ParquetWriter(lowercase_ , schema=lowercase_ , **lowercase_) for offset in logging.tqdm( range(0 , len(self.dataset) , lowercase_) , unit='''ba''' , disable=not logging.is_progress_bar_enabled() , desc='''Creating parquet from Arrow format''' , ): SCREAMING_SNAKE_CASE_ : List[Any] = query_table( table=self.dataset._data , key=slice(lowercase_ , offset + batch_size) , indices=self.dataset._indices if self.dataset._indices is not None else None , ) writer.write_table(lowercase_) written += batch.nbytes writer.close() return written
318
0
"""simple docstring""" import unittest from transformers import DonutProcessor UpperCAmelCase_ : Optional[Any] = """naver-clova-ix/donut-base""" class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = DonutProcessor.from_pretrained(lowercase_) def _SCREAMING_SNAKE_CASE ( self : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = { '''name''': '''John Doe''', '''age''': '''99''', '''city''': '''Atlanta''', '''state''': '''GA''', '''zip''': '''30301''', '''phone''': '''123-4567''', '''nicknames''': [{'''nickname''': '''Johnny'''}, {'''nickname''': '''JD'''}], } SCREAMING_SNAKE_CASE_ : Any = ( '''<s_name>John Doe</s_name><s_age>99</s_age><s_city>Atlanta</s_city>''' '''<s_state>GA</s_state><s_zip>30301</s_zip><s_phone>123-4567</s_phone>''' '''<s_nicknames><s_nickname>Johnny</s_nickname>''' '''<sep/><s_nickname>JD</s_nickname></s_nicknames>''' ) SCREAMING_SNAKE_CASE_ : Any = self.processor.tokenajson(lowercase_) self.assertDictEqual(lowercase_ , lowercase_)
359
"""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() UpperCAmelCase_ : str = logging.get_logger(__name__) UpperCAmelCase_ : Optional[Any] = ["""model.decoder.embed_positions.weights"""] def _A (__a ) -> Dict: """simple docstring""" if "emb" in name: SCREAMING_SNAKE_CASE_ : Optional[int] = name.replace('''emb''' , '''model.decoder.embed_tokens''' ) if "transformer" in name: SCREAMING_SNAKE_CASE_ : Tuple = name.replace('''transformer''' , '''model.decoder''' ) if "cross_attention" in name: SCREAMING_SNAKE_CASE_ : str = name.replace('''cross_attention''' , '''encoder_attn''' ) if "linear1" in name: SCREAMING_SNAKE_CASE_ : Optional[int] = name.replace('''linear1''' , '''fc1''' ) if "linear2" in name: SCREAMING_SNAKE_CASE_ : str = name.replace('''linear2''' , '''fc2''' ) if "norm1" in name: SCREAMING_SNAKE_CASE_ : Any = name.replace('''norm1''' , '''self_attn_layer_norm''' ) if "norm_cross" in name: SCREAMING_SNAKE_CASE_ : List[str] = name.replace('''norm_cross''' , '''encoder_attn_layer_norm''' ) if "norm2" in name: SCREAMING_SNAKE_CASE_ : Tuple = name.replace('''norm2''' , '''final_layer_norm''' ) if "out_norm" in name: SCREAMING_SNAKE_CASE_ : List[str] = name.replace('''out_norm''' , '''model.decoder.layer_norm''' ) if "linears" in name: SCREAMING_SNAKE_CASE_ : Dict = name.replace('''linears''' , '''lm_heads''' ) if "condition_provider.conditioners.description.output_proj" in name: SCREAMING_SNAKE_CASE_ : List[str] = name.replace('''condition_provider.conditioners.description.output_proj''' , '''enc_to_dec_proj''' ) return name def _A (__a , __a ) -> Tuple[Dict, Dict]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Union[str, Any] = list(state_dict.keys() ) SCREAMING_SNAKE_CASE_ : int = {} for key in keys: SCREAMING_SNAKE_CASE_ : int = state_dict.pop(__a ) SCREAMING_SNAKE_CASE_ : int = rename_keys(__a ) if "in_proj_weight" in key: # split fused qkv proj SCREAMING_SNAKE_CASE_ : List[str] = val[:hidden_size, :] SCREAMING_SNAKE_CASE_ : List[str] = val[hidden_size : 2 * hidden_size, :] SCREAMING_SNAKE_CASE_ : Optional[Any] = val[-hidden_size:, :] elif "enc_to_dec_proj" in key: SCREAMING_SNAKE_CASE_ : int = val else: SCREAMING_SNAKE_CASE_ : Any = val return state_dict, enc_dec_proj_state_dict def _A (__a ) -> MusicgenDecoderConfig: """simple docstring""" if checkpoint == "small": # default config values SCREAMING_SNAKE_CASE_ : Optional[int] = 10_24 SCREAMING_SNAKE_CASE_ : Tuple = 24 SCREAMING_SNAKE_CASE_ : Optional[Any] = 16 elif checkpoint == "medium": SCREAMING_SNAKE_CASE_ : List[str] = 15_36 SCREAMING_SNAKE_CASE_ : Optional[int] = 48 SCREAMING_SNAKE_CASE_ : Optional[int] = 24 elif checkpoint == "large": SCREAMING_SNAKE_CASE_ : Optional[Any] = 20_48 SCREAMING_SNAKE_CASE_ : Optional[int] = 48 SCREAMING_SNAKE_CASE_ : int = 32 else: raise ValueError(f'Checkpoint should be one of `[\'small\', \'medium\', \'large\']`, got {checkpoint}.' ) SCREAMING_SNAKE_CASE_ : List[Any] = MusicgenDecoderConfig( hidden_size=__a , ffn_dim=hidden_size * 4 , num_hidden_layers=__a , num_attention_heads=__a , ) return config @torch.no_grad() def _A (__a , __a=None , __a=None , __a="cpu" ) -> List[str]: """simple docstring""" SCREAMING_SNAKE_CASE_ : Any = MusicGen.get_pretrained(__a , device=__a ) SCREAMING_SNAKE_CASE_ : Dict = decoder_config_from_checkpoint(__a ) SCREAMING_SNAKE_CASE_ : Optional[Any] = fairseq_model.lm.state_dict() SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : int = rename_state_dict( __a , hidden_size=decoder_config.hidden_size ) SCREAMING_SNAKE_CASE_ : Optional[Any] = TaEncoderModel.from_pretrained('''t5-base''' ) SCREAMING_SNAKE_CASE_ : List[str] = EncodecModel.from_pretrained('''facebook/encodec_32khz''' ) SCREAMING_SNAKE_CASE_ : int = MusicgenForCausalLM(__a ).eval() # load all decoder weights - expect that we'll be missing embeddings and enc-dec projection SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : List[str] = decoder.load_state_dict(__a , strict=__a ) for key in missing_keys.copy(): if key.startswith(('''text_encoder''', '''audio_encoder''') ) or key in EXPECTED_MISSING_KEYS: missing_keys.remove(__a ) if len(__a ) > 0: raise ValueError(f'Missing key(s) in state_dict: {missing_keys}' ) if len(__a ) > 0: raise ValueError(f'Unexpected key(s) in state_dict: {unexpected_keys}' ) # init the composite model SCREAMING_SNAKE_CASE_ : str = MusicgenForConditionalGeneration(text_encoder=__a , audio_encoder=__a , decoder=__a ) # load the pre-trained enc-dec projection (from the decoder state dict) model.enc_to_dec_proj.load_state_dict(__a ) # check we can do a forward pass SCREAMING_SNAKE_CASE_ : Dict = torch.arange(0 , 8 , dtype=torch.long ).reshape(2 , -1 ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = input_ids.reshape(2 * 4 , -1 ) with torch.no_grad(): SCREAMING_SNAKE_CASE_ : List[Any] = model(input_ids=__a , decoder_input_ids=__a ).logits if logits.shape != (8, 1, 20_48): raise ValueError('''Incorrect shape for logits''' ) # now construct the processor SCREAMING_SNAKE_CASE_ : str = AutoTokenizer.from_pretrained('''t5-base''' ) SCREAMING_SNAKE_CASE_ : str = AutoFeatureExtractor.from_pretrained('''facebook/encodec_32khz''' , padding_side='''left''' ) SCREAMING_SNAKE_CASE_ : Tuple = MusicgenProcessor(feature_extractor=__a , tokenizer=__a ) # set the appropriate bos/pad token ids SCREAMING_SNAKE_CASE_ : str = 20_48 SCREAMING_SNAKE_CASE_ : List[Any] = 20_48 # set other default generation config params SCREAMING_SNAKE_CASE_ : int = int(30 * audio_encoder.config.frame_rate ) SCREAMING_SNAKE_CASE_ : str = True SCREAMING_SNAKE_CASE_ : Optional[Any] = 3.0 if pytorch_dump_folder is not None: Path(__a ).mkdir(exist_ok=__a ) logger.info(f'Saving model {checkpoint} to {pytorch_dump_folder}' ) model.save_pretrained(__a ) processor.save_pretrained(__a ) if repo_id: logger.info(f'Pushing model {checkpoint} to {repo_id}' ) model.push_to_hub(__a ) processor.push_to_hub(__a ) if __name__ == "__main__": UpperCAmelCase_ : Dict = 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.""" ) UpperCAmelCase_ : Dict = parser.parse_args() convert_musicgen_checkpoint(args.checkpoint, args.pytorch_dump_folder, args.push_to_hub)
318
0
from queue import PriorityQueue from typing import Any import numpy as np def _A (__a , __a , __a , __a , __a , __a , __a , __a , __a , ) -> float | int: """simple docstring""" for nxt, d in graph[v]: if nxt in visited_forward: continue SCREAMING_SNAKE_CASE_ : Tuple = cst_fwd.get(__a , np.inf ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = cst_fwd[v] + d if new_cost_f < old_cost_f: queue.put((new_cost_f, nxt) ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = new_cost_f SCREAMING_SNAKE_CASE_ : List[Any] = v if nxt in visited_backward: if cst_fwd[v] + d + cst_bwd[nxt] < shortest_distance: SCREAMING_SNAKE_CASE_ : int = cst_fwd[v] + d + cst_bwd[nxt] return shortest_distance def _A (__a , __a , __a , __a ) -> int: """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[Any] = -1 SCREAMING_SNAKE_CASE_ : int = set() SCREAMING_SNAKE_CASE_ : Tuple = set() SCREAMING_SNAKE_CASE_ : Tuple = {source: 0} SCREAMING_SNAKE_CASE_ : Optional[int] = {destination: 0} SCREAMING_SNAKE_CASE_ : Tuple = {source: None} SCREAMING_SNAKE_CASE_ : Tuple = {destination: None} SCREAMING_SNAKE_CASE_ : PriorityQueue[Any] = PriorityQueue() SCREAMING_SNAKE_CASE_ : PriorityQueue[Any] = PriorityQueue() SCREAMING_SNAKE_CASE_ : Optional[Any] = np.inf queue_forward.put((0, source) ) queue_backward.put((0, destination) ) if source == destination: return 0 while not queue_forward.empty() and not queue_backward.empty(): SCREAMING_SNAKE_CASE_ : Dict = queue_forward.get() visited_forward.add(__a ) SCREAMING_SNAKE_CASE_ : Optional[int] = queue_backward.get() visited_backward.add(__a ) SCREAMING_SNAKE_CASE_ : Tuple = pass_and_relaxation( __a , __a , __a , __a , __a , __a , __a , __a , __a , ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = pass_and_relaxation( __a , __a , __a , __a , __a , __a , __a , __a , __a , ) if cst_fwd[v_fwd] + cst_bwd[v_bwd] >= shortest_distance: break if shortest_distance != np.inf: SCREAMING_SNAKE_CASE_ : List[str] = shortest_distance return shortest_path_distance UpperCAmelCase_ : List[str] = { """B""": [["""C""", 1]], """C""": [["""D""", 1]], """D""": [["""F""", 1]], """E""": [["""B""", 1], ["""G""", 2]], """F""": [], """G""": [["""F""", 1]], } UpperCAmelCase_ : int = { """B""": [["""E""", 1]], """C""": [["""B""", 1]], """D""": [["""C""", 1]], """F""": [["""D""", 1], ["""G""", 1]], """E""": [[None, np.inf]], """G""": [["""E""", 2]], } if __name__ == "__main__": import doctest doctest.testmod()
360
"""simple docstring""" from pathlib import Path import numpy as np from PIL import Image def _A (__a ) -> np.ndarray: """simple docstring""" SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Optional[int] = rgb[:, :, 0], rgb[:, :, 1], rgb[:, :, 2] return 0.29_89 * r + 0.58_70 * g + 0.11_40 * b def _A (__a ) -> np.ndarray: """simple docstring""" return (gray > 1_27) & (gray <= 2_55) def _A (__a , __a ) -> np.ndarray: """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[Any] = np.zeros_like(__a ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = np.zeros( (image.shape[0] + kernel.shape[0] - 1, image.shape[1] + kernel.shape[1] - 1) ) # Copy image to padded image SCREAMING_SNAKE_CASE_ : Union[str, Any] = image # Iterate over image & apply kernel for x in range(image.shape[1] ): for y in range(image.shape[0] ): SCREAMING_SNAKE_CASE_ : Optional[Any] = ( kernel * image_padded[y : y + kernel.shape[0], x : x + kernel.shape[1]] ).sum() SCREAMING_SNAKE_CASE_ : Any = int(summation > 0 ) return output if __name__ == "__main__": # read original image UpperCAmelCase_ : Dict = Path(__file__).resolve().parent / """image_data""" / """lena.jpg""" UpperCAmelCase_ : List[Any] = np.array(Image.open(lena_path)) # kernel to be applied UpperCAmelCase_ : Any = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]]) UpperCAmelCase_ : Tuple = dilation(gray_to_binary(rgb_to_gray(lena)), structuring_element) # Save the output image UpperCAmelCase_ : List[str] = Image.fromarray(output).convert("""RGB""") pil_img.save("""result_dilation.png""")
318
0
"""simple docstring""" from collections.abc import Callable class lowerCAmelCase__ : '''simple docstring''' def __init__( self : Any , lowercase_ : Callable | None = None): '''simple docstring''' SCREAMING_SNAKE_CASE_ : list = [] # Stores indexes of each item for supporting updates and deletion. SCREAMING_SNAKE_CASE_ : dict = {} # Stores current size of heap. SCREAMING_SNAKE_CASE_ : int = 0 # Stores function used to evaluate the score of an item on which basis ordering # will be done. SCREAMING_SNAKE_CASE_ : Any = key or (lambda lowercase_: x) def _SCREAMING_SNAKE_CASE ( self : List[str] , lowercase_ : int): '''simple docstring''' return int((i - 1) / 2) if i > 0 else None def _SCREAMING_SNAKE_CASE ( self : Union[str, Any] , lowercase_ : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = int(2 * i + 1) return left if 0 < left < self.size else None def _SCREAMING_SNAKE_CASE ( self : int , lowercase_ : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = int(2 * i + 2) return right if 0 < right < self.size else None def _SCREAMING_SNAKE_CASE ( self : List[str] , lowercase_ : int , lowercase_ : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[Any] = ( self.pos_map[self.arr[j][0]], self.pos_map[self.arr[i][0]], ) # Then swap the items in the list. SCREAMING_SNAKE_CASE_ : int = self.arr[j], self.arr[i] def _SCREAMING_SNAKE_CASE ( self : int , lowercase_ : int , lowercase_ : int): '''simple docstring''' return self.arr[i][1] < self.arr[j][1] def _SCREAMING_SNAKE_CASE ( self : str , lowercase_ : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = self._left(lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = self._right(lowercase_) SCREAMING_SNAKE_CASE_ : List[Any] = i if left is not None and not self._cmp(lowercase_ , lowercase_): SCREAMING_SNAKE_CASE_ : str = left if right is not None and not self._cmp(lowercase_ , lowercase_): SCREAMING_SNAKE_CASE_ : Optional[int] = right return valid_parent def _SCREAMING_SNAKE_CASE ( self : Dict , lowercase_ : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = self._parent(lowercase_) while parent is not None and not self._cmp(lowercase_ , lowercase_): self._swap(lowercase_ , lowercase_) SCREAMING_SNAKE_CASE_ : int = parent, self._parent(lowercase_) def _SCREAMING_SNAKE_CASE ( self : Optional[int] , lowercase_ : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Tuple = self._get_valid_parent(lowercase_) while valid_parent != index: self._swap(lowercase_ , lowercase_) SCREAMING_SNAKE_CASE_ : int = valid_parent, self._get_valid_parent(lowercase_) def _SCREAMING_SNAKE_CASE ( self : str , lowercase_ : int , lowercase_ : int): '''simple docstring''' if item not in self.pos_map: return SCREAMING_SNAKE_CASE_ : Dict = self.pos_map[item] SCREAMING_SNAKE_CASE_ : Optional[Any] = [item, self.key(lowercase_)] # Make sure heap is right in both up and down direction. # Ideally only one of them will make any change. self._heapify_up(lowercase_) self._heapify_down(lowercase_) def _SCREAMING_SNAKE_CASE ( self : List[Any] , lowercase_ : int): '''simple docstring''' if item not in self.pos_map: return SCREAMING_SNAKE_CASE_ : Any = self.pos_map[item] del self.pos_map[item] SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.arr[self.size - 1] SCREAMING_SNAKE_CASE_ : List[Any] = index self.size -= 1 # Make sure heap is right in both up and down direction. Ideally only one # of them will make any change- so no performance loss in calling both. if self.size > index: self._heapify_up(lowercase_) self._heapify_down(lowercase_) def _SCREAMING_SNAKE_CASE ( self : Union[str, Any] , lowercase_ : int , lowercase_ : int): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = len(self.arr) if arr_len == self.size: self.arr.append([item, self.key(lowercase_)]) else: SCREAMING_SNAKE_CASE_ : Union[str, Any] = [item, self.key(lowercase_)] SCREAMING_SNAKE_CASE_ : Union[str, Any] = self.size self.size += 1 self._heapify_up(self.size - 1) def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): '''simple docstring''' return self.arr[0] if self.size else None def _SCREAMING_SNAKE_CASE ( self : Any): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[str] = self.get_top() if top_item_tuple: self.delete_item(top_item_tuple[0]) return top_item_tuple def _A () -> None: """simple docstring""" if __name__ == "__main__": import doctest doctest.testmod()
361
"""simple docstring""" from collections import defaultdict def _A (__a , __a ) -> bool: """simple docstring""" SCREAMING_SNAKE_CASE_ : Dict = first_str.lower().strip() SCREAMING_SNAKE_CASE_ : List[Any] = second_str.lower().strip() # Remove whitespace SCREAMING_SNAKE_CASE_ : Dict = first_str.replace(''' ''' , '''''' ) SCREAMING_SNAKE_CASE_ : Optional[Any] = second_str.replace(''' ''' , '''''' ) # Strings of different lengths are not anagrams if len(__a ) != len(__a ): return False # Default values for count should be 0 SCREAMING_SNAKE_CASE_ : defaultdict[str, int] = defaultdict(__a ) # For each character in input strings, # increment count in the corresponding for i in range(len(__a ) ): count[first_str[i]] += 1 count[second_str[i]] -= 1 return all(_count == 0 for _count in count.values() ) if __name__ == "__main__": from doctest import testmod testmod() UpperCAmelCase_ : Any = input("""Enter the first string """).strip() UpperCAmelCase_ : Optional[int] = input("""Enter the second string """).strip() UpperCAmelCase_ : Union[str, Any] = check_anagrams(input_a, input_b) print(f'''{input_a} and {input_b} are {'' if status else 'not '}anagrams.''')
318
0
"""simple docstring""" import os from typing import BinaryIO, Optional, Union import numpy as np import pyarrow.parquet as pq from .. import Audio, Dataset, Features, Image, NamedSplit, Value, config from ..features.features import FeatureType, _visit from ..formatting import query_table from ..packaged_modules import _PACKAGED_DATASETS_MODULES from ..packaged_modules.parquet.parquet import Parquet from ..utils import logging from ..utils.typing import NestedDataStructureLike, PathLike from .abc import AbstractDatasetReader def _A (__a ) -> Optional[int]: """simple docstring""" SCREAMING_SNAKE_CASE_ : List[str] = np.inf def set_batch_size(__a ) -> None: nonlocal batch_size if isinstance(__a , __a ): SCREAMING_SNAKE_CASE_ : Tuple = min(__a , config.PARQUET_ROW_GROUP_SIZE_FOR_IMAGE_DATASETS ) elif isinstance(__a , __a ): SCREAMING_SNAKE_CASE_ : int = min(__a , config.PARQUET_ROW_GROUP_SIZE_FOR_AUDIO_DATASETS ) elif isinstance(__a , __a ) and feature.dtype == "binary": SCREAMING_SNAKE_CASE_ : Union[str, Any] = min(__a , config.PARQUET_ROW_GROUP_SIZE_FOR_BINARY_DATASETS ) _visit(__a , __a ) return None if batch_size is np.inf else batch_size class lowerCAmelCase__ ( UpperCAmelCase__ ): '''simple docstring''' def __init__( self : Any , lowercase_ : NestedDataStructureLike[PathLike] , lowercase_ : Optional[NamedSplit] = None , lowercase_ : Optional[Features] = None , lowercase_ : str = None , lowercase_ : bool = False , lowercase_ : bool = False , lowercase_ : Optional[int] = None , **lowercase_ : Optional[int] , ): '''simple docstring''' super().__init__( lowercase_ , split=lowercase_ , features=lowercase_ , cache_dir=lowercase_ , keep_in_memory=lowercase_ , streaming=lowercase_ , num_proc=lowercase_ , **lowercase_ , ) SCREAMING_SNAKE_CASE_ : Any = path_or_paths if isinstance(lowercase_ , lowercase_) else {self.split: path_or_paths} SCREAMING_SNAKE_CASE_ : Any = _PACKAGED_DATASETS_MODULES['''parquet'''][1] SCREAMING_SNAKE_CASE_ : Union[str, Any] = Parquet( cache_dir=lowercase_ , data_files=lowercase_ , features=lowercase_ , hash=lowercase_ , **lowercase_ , ) def _SCREAMING_SNAKE_CASE ( self : Tuple): '''simple docstring''' if self.streaming: SCREAMING_SNAKE_CASE_ : str = self.builder.as_streaming_dataset(split=self.split) # Build regular (map-style) dataset else: SCREAMING_SNAKE_CASE_ : Optional[Any] = None SCREAMING_SNAKE_CASE_ : Optional[int] = None SCREAMING_SNAKE_CASE_ : Tuple = None SCREAMING_SNAKE_CASE_ : Dict = None self.builder.download_and_prepare( download_config=lowercase_ , download_mode=lowercase_ , verification_mode=lowercase_ , base_path=lowercase_ , num_proc=self.num_proc , ) SCREAMING_SNAKE_CASE_ : Any = self.builder.as_dataset( split=self.split , verification_mode=lowercase_ , in_memory=self.keep_in_memory) return dataset class lowerCAmelCase__ : '''simple docstring''' def __init__( self : Tuple , lowercase_ : Dataset , lowercase_ : Union[PathLike, BinaryIO] , lowercase_ : Optional[int] = None , **lowercase_ : Dict , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = dataset SCREAMING_SNAKE_CASE_ : Dict = path_or_buf SCREAMING_SNAKE_CASE_ : List[Any] = batch_size or get_writer_batch_size(dataset.features) SCREAMING_SNAKE_CASE_ : Any = parquet_writer_kwargs def _SCREAMING_SNAKE_CASE ( self : List[Any]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : List[str] = self.batch_size if self.batch_size else config.DEFAULT_MAX_BATCH_SIZE if isinstance(self.path_or_buf , (str, bytes, os.PathLike)): with open(self.path_or_buf , '''wb+''') as buffer: SCREAMING_SNAKE_CASE_ : Optional[Any] = self._write(file_obj=lowercase_ , batch_size=lowercase_ , **self.parquet_writer_kwargs) else: SCREAMING_SNAKE_CASE_ : str = self._write(file_obj=self.path_or_buf , batch_size=lowercase_ , **self.parquet_writer_kwargs) return written def _SCREAMING_SNAKE_CASE ( self : Tuple , lowercase_ : BinaryIO , lowercase_ : int , **lowercase_ : List[str]): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Any = 0 SCREAMING_SNAKE_CASE_ : Optional[int] = parquet_writer_kwargs.pop('''path_or_buf''' , lowercase_) SCREAMING_SNAKE_CASE_ : List[str] = self.dataset.features.arrow_schema SCREAMING_SNAKE_CASE_ : Tuple = pq.ParquetWriter(lowercase_ , schema=lowercase_ , **lowercase_) for offset in logging.tqdm( range(0 , len(self.dataset) , lowercase_) , unit='''ba''' , disable=not logging.is_progress_bar_enabled() , desc='''Creating parquet from Arrow format''' , ): SCREAMING_SNAKE_CASE_ : List[Any] = query_table( table=self.dataset._data , key=slice(lowercase_ , offset + batch_size) , indices=self.dataset._indices if self.dataset._indices is not None else None , ) writer.write_table(lowercase_) written += batch.nbytes writer.close() return written
362
"""simple docstring""" import argparse from collections import defaultdict import yaml UpperCAmelCase_ : Optional[Any] = """docs/source/en/_toctree.yml""" def _A (__a ) -> Union[str, Any]: """simple docstring""" SCREAMING_SNAKE_CASE_ : str = defaultdict(__a ) for doc in model_doc: counts[doc["local"]] += 1 SCREAMING_SNAKE_CASE_ : List[Any] = [key for key, value in counts.items() if value > 1] SCREAMING_SNAKE_CASE_ : int = [] for duplicate_key in duplicates: SCREAMING_SNAKE_CASE_ : List[str] = list({doc['''title'''] for doc in model_doc if doc['''local'''] == duplicate_key} ) if len(__a ) > 1: raise ValueError( f'{duplicate_key} is present several times in the documentation table of content at ' '''`docs/source/en/_toctree.yml` with different *Title* values. Choose one of those and remove the ''' '''others.''' ) # Only add this once new_doc.append({'''local''': duplicate_key, '''title''': titles[0]} ) # Add none duplicate-keys new_doc.extend([doc for doc in model_doc if counts[doc['''local''']] == 1] ) # Sort return sorted(__a , key=lambda __a : s["title"].lower() ) def _A (__a=False ) -> Tuple: """simple docstring""" with open(__a , encoding='''utf-8''' ) as f: SCREAMING_SNAKE_CASE_ : Dict = yaml.safe_load(f.read() ) # Get to the API doc SCREAMING_SNAKE_CASE_ : Any = 0 while content[api_idx]["title"] != "API": api_idx += 1 SCREAMING_SNAKE_CASE_ : str = content[api_idx]['''sections'''] # Then to the model doc SCREAMING_SNAKE_CASE_ : List[Any] = 0 while api_doc[model_idx]["title"] != "Models": model_idx += 1 SCREAMING_SNAKE_CASE_ : Optional[int] = api_doc[model_idx]['''sections'''] SCREAMING_SNAKE_CASE_ : str = [(idx, section) for idx, section in enumerate(__a ) if '''sections''' in section] SCREAMING_SNAKE_CASE_ : Optional[Any] = False for idx, modality_doc in modalities_docs: SCREAMING_SNAKE_CASE_ : List[str] = modality_doc['''sections'''] SCREAMING_SNAKE_CASE_ : Union[str, Any] = clean_model_doc_toc(__a ) if old_modality_doc != new_modality_doc: SCREAMING_SNAKE_CASE_ : str = True if overwrite: SCREAMING_SNAKE_CASE_ : Optional[int] = new_modality_doc if diff: if overwrite: SCREAMING_SNAKE_CASE_ : List[Any] = model_doc SCREAMING_SNAKE_CASE_ : int = api_doc with open(__a , '''w''' , encoding='''utf-8''' ) as f: f.write(yaml.dump(__a , allow_unicode=__a ) ) else: raise ValueError( '''The model doc part of the table of content is not properly sorted, run `make style` to fix this.''' ) if __name__ == "__main__": UpperCAmelCase_ : List[str] = argparse.ArgumentParser() parser.add_argument("""--fix_and_overwrite""", action="""store_true""", help="""Whether to fix inconsistencies.""") UpperCAmelCase_ : Tuple = parser.parse_args() check_model_doc(args.fix_and_overwrite)
318
0
"""simple docstring""" from ...utils import ( OptionalDependencyNotAvailable, is_torch_available, is_transformers_available, is_transformers_version, ) try: if not (is_transformers_available() and is_torch_available() and is_transformers_version(""">=""", """4.25.0""")): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ...utils.dummy_torch_and_transformers_objects import ( VersatileDiffusionDualGuidedPipeline, VersatileDiffusionImageVariationPipeline, VersatileDiffusionPipeline, VersatileDiffusionTextToImagePipeline, ) else: from .modeling_text_unet import UNetFlatConditionModel from .pipeline_versatile_diffusion import VersatileDiffusionPipeline from .pipeline_versatile_diffusion_dual_guided import VersatileDiffusionDualGuidedPipeline from .pipeline_versatile_diffusion_image_variation import VersatileDiffusionImageVariationPipeline from .pipeline_versatile_diffusion_text_to_image import VersatileDiffusionTextToImagePipeline
363
"""simple docstring""" from ...utils import ( OptionalDependencyNotAvailable, is_torch_available, is_transformers_available, is_transformers_version, ) try: if not (is_transformers_available() and is_torch_available() and is_transformers_version(""">=""", """4.25.0""")): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ...utils.dummy_torch_and_transformers_objects import ( VersatileDiffusionDualGuidedPipeline, VersatileDiffusionImageVariationPipeline, VersatileDiffusionPipeline, VersatileDiffusionTextToImagePipeline, ) else: from .modeling_text_unet import UNetFlatConditionModel from .pipeline_versatile_diffusion import VersatileDiffusionPipeline from .pipeline_versatile_diffusion_dual_guided import VersatileDiffusionDualGuidedPipeline from .pipeline_versatile_diffusion_image_variation import VersatileDiffusionImageVariationPipeline from .pipeline_versatile_diffusion_text_to_image import VersatileDiffusionTextToImagePipeline
318
0
"""simple docstring""" import sacrebleu as scb from packaging import version from sacrebleu import TER import datasets UpperCAmelCase_ : str = """\ @inproceedings{snover-etal-2006-study, title = \"A Study of Translation Edit Rate with Targeted Human Annotation\", author = \"Snover, Matthew and Dorr, Bonnie and Schwartz, Rich and Micciulla, Linnea and Makhoul, John\", booktitle = \"Proceedings of the 7th Conference of the Association for Machine Translation in the Americas: Technical Papers\", month = aug # \" 8-12\", year = \"2006\", address = \"Cambridge, Massachusetts, USA\", publisher = \"Association for Machine Translation in the Americas\", url = \"https://aclanthology.org/2006.amta-papers.25\", pages = \"223--231\", } @inproceedings{post-2018-call, title = \"A Call for Clarity in Reporting {BLEU} Scores\", author = \"Post, Matt\", booktitle = \"Proceedings of the Third Conference on Machine Translation: Research Papers\", month = oct, year = \"2018\", address = \"Belgium, Brussels\", publisher = \"Association for Computational Linguistics\", url = \"https://www.aclweb.org/anthology/W18-6319\", pages = \"186--191\", } """ UpperCAmelCase_ : Any = """\ TER (Translation Edit Rate, also called Translation Error Rate) is a metric to quantify the edit operations that a hypothesis requires to match a reference translation. We use the implementation that is already present in sacrebleu (https://github.com/mjpost/sacreBLEU#ter), which in turn is inspired by the TERCOM implementation, which can be found here: https://github.com/jhclark/tercom. The implementation here is slightly different from sacrebleu in terms of the required input format. The length of the references and hypotheses lists need to be the same, so you may need to transpose your references compared to sacrebleu's required input format. See https://github.com/huggingface/datasets/issues/3154#issuecomment-950746534 See the README.md file at https://github.com/mjpost/sacreBLEU#ter for more information. """ UpperCAmelCase_ : List[Any] = """ Produces TER scores alongside the number of edits and reference length. Args: predictions (list of str): The system stream (a sequence of segments). references (list of list of str): A list of one or more reference streams (each a sequence of segments). normalized (boolean): If `True`, applies basic tokenization and normalization to sentences. Defaults to `False`. ignore_punct (boolean): If `True`, applies basic tokenization and normalization to sentences. Defaults to `False`. support_zh_ja_chars (boolean): If `True`, tokenization/normalization supports processing of Chinese characters, as well as Japanese Kanji, Hiragana, Katakana, and Phonetic Extensions of Katakana. Only applies if `normalized = True`. Defaults to `False`. case_sensitive (boolean): If `False`, makes all predictions and references lowercase to ignore differences in case. Defaults to `False`. Returns: 'score' (float): TER score (num_edits / sum_ref_lengths * 100) 'num_edits' (int): The cumulative number of edits 'ref_length' (float): The cumulative average reference length Examples: Example 1: >>> predictions = [\"does this sentence match??\", ... \"what about this sentence?\", ... \"What did the TER metric user say to the developer?\"] >>> references = [[\"does this sentence match\", \"does this sentence match!?!\"], ... [\"wHaT aBoUt ThIs SeNtEnCe?\", \"wHaT aBoUt ThIs SeNtEnCe?\"], ... [\"Your jokes are...\", \"...TERrible\"]] >>> ter = datasets.load_metric(\"ter\") >>> results = ter.compute(predictions=predictions, ... references=references, ... case_sensitive=True) >>> print(results) {'score': 150.0, 'num_edits': 15, 'ref_length': 10.0} Example 2: >>> predictions = [\"does this sentence match??\", ... \"what about this sentence?\"] >>> references = [[\"does this sentence match\", \"does this sentence match!?!\"], ... [\"wHaT aBoUt ThIs SeNtEnCe?\", \"wHaT aBoUt ThIs SeNtEnCe?\"]] >>> ter = datasets.load_metric(\"ter\") >>> results = ter.compute(predictions=predictions, ... references=references, ... case_sensitive=True) >>> print(results) {'score': 62.5, 'num_edits': 5, 'ref_length': 8.0} Example 3: >>> predictions = [\"does this sentence match??\", ... \"what about this sentence?\"] >>> references = [[\"does this sentence match\", \"does this sentence match!?!\"], ... [\"wHaT aBoUt ThIs SeNtEnCe?\", \"wHaT aBoUt ThIs SeNtEnCe?\"]] >>> ter = datasets.load_metric(\"ter\") >>> results = ter.compute(predictions=predictions, ... references=references, ... normalized=True, ... case_sensitive=True) >>> print(results) {'score': 57.14285714285714, 'num_edits': 6, 'ref_length': 10.5} Example 4: >>> predictions = [\"does this sentence match??\", ... \"what about this sentence?\"] >>> references = [[\"does this sentence match\", \"does this sentence match!?!\"], ... [\"wHaT aBoUt ThIs SeNtEnCe?\", \"wHaT aBoUt ThIs SeNtEnCe?\"]] >>> ter = datasets.load_metric(\"ter\") >>> results = ter.compute(predictions=predictions, ... references=references, ... ignore_punct=True, ... case_sensitive=False) >>> print(results) {'score': 0.0, 'num_edits': 0, 'ref_length': 8.0} Example 5: >>> predictions = [\"does this sentence match??\", ... \"what about this sentence?\", ... \"What did the TER metric user say to the developer?\"] >>> references = [[\"does this sentence match\", \"does this sentence match!?!\"], ... [\"wHaT aBoUt ThIs SeNtEnCe?\", \"wHaT aBoUt ThIs SeNtEnCe?\"], ... [\"Your jokes are...\", \"...TERrible\"]] >>> ter = datasets.load_metric(\"ter\") >>> results = ter.compute(predictions=predictions, ... references=references, ... ignore_punct=True, ... case_sensitive=False) >>> print(results) {'score': 100.0, 'num_edits': 10, 'ref_length': 10.0} """ @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class lowerCAmelCase__ ( datasets.Metric ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : Dict): '''simple docstring''' if version.parse(scb.__version__) < version.parse('''1.4.12'''): raise ImportWarning( '''To use `sacrebleu`, the module `sacrebleu>=1.4.12` is required, and the current version of `sacrebleu` doesn\'t match this condition.\n''' '''You can install it with `pip install "sacrebleu>=1.4.12"`.''') return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , homepage='''http://www.cs.umd.edu/~snover/tercom/''' , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { '''predictions''': datasets.Value('''string''' , id='''sequence'''), '''references''': datasets.Sequence(datasets.Value('''string''' , id='''sequence''') , id='''references'''), }) , codebase_urls=['''https://github.com/mjpost/sacreBLEU#ter'''] , reference_urls=[ '''https://github.com/jhclark/tercom''', ] , ) def _SCREAMING_SNAKE_CASE ( self : Optional[Any] , lowercase_ : Optional[int] , lowercase_ : Dict , lowercase_ : bool = False , lowercase_ : bool = False , lowercase_ : bool = False , lowercase_ : bool = False , ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : Dict = len(references[0]) if any(len(lowercase_) != references_per_prediction for refs in references): raise ValueError('''Sacrebleu requires the same number of references for each prediction''') SCREAMING_SNAKE_CASE_ : Dict = [[refs[i] for refs in references] for i in range(lowercase_)] SCREAMING_SNAKE_CASE_ : int = TER( normalized=lowercase_ , no_punct=lowercase_ , asian_support=lowercase_ , case_sensitive=lowercase_ , ) SCREAMING_SNAKE_CASE_ : Any = sb_ter.corpus_score(lowercase_ , lowercase_) return {"score": output.score, "num_edits": output.num_edits, "ref_length": output.ref_length}
364
"""simple docstring""" from __future__ import annotations UpperCAmelCase_ : List[str] = list[list[int]] # assigning initial values to the grid UpperCAmelCase_ : Matrix = [ [3, 0, 6, 5, 0, 8, 4, 0, 0], [5, 2, 0, 0, 0, 0, 0, 0, 0], [0, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] # a grid with no solution UpperCAmelCase_ : Matrix = [ [5, 0, 6, 5, 0, 8, 4, 0, 3], [5, 2, 0, 0, 0, 0, 0, 0, 2], [1, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] def _A (__a , __a , __a , __a ) -> bool: """simple docstring""" for i in range(9 ): if grid[row][i] == n or grid[i][column] == n: return False for i in range(3 ): for j in range(3 ): if grid[(row - row % 3) + i][(column - column % 3) + j] == n: return False return True def _A (__a ) -> tuple[int, int] | None: """simple docstring""" for i in range(9 ): for j in range(9 ): if grid[i][j] == 0: return i, j return None def _A (__a ) -> Matrix | None: """simple docstring""" if location := find_empty_location(__a ): SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Dict = location else: # If the location is ``None``, then the grid is solved. return grid for digit in range(1 , 10 ): if is_safe(__a , __a , __a , __a ): SCREAMING_SNAKE_CASE_ : Tuple = digit if sudoku(__a ) is not None: return grid SCREAMING_SNAKE_CASE_ : Any = 0 return None def _A (__a ) -> None: """simple docstring""" for row in grid: for cell in row: print(__a , end=''' ''' ) print() if __name__ == "__main__": # make a copy of grid so that you can compare with the unmodified grid for example_grid in (initial_grid, no_solution): print("""\nExample grid:\n""" + """=""" * 20) print_solution(example_grid) print("""\nExample grid solution:""") UpperCAmelCase_ : str = sudoku(example_grid) if solution is not None: print_solution(solution) else: print("""Cannot find a solution.""")
318
0