Datasets:

infinityofspace

/

python_codestyles-mixed1-500

like 0

'''simple docstring''' import argparse import struct import unittest class UpperCAmelCase : '''simple docstring''' def __init__( self , __lowerCAmelCase ) -> None: lowercase__ : List[str] = data # Initialize hash values lowercase__ : Union[str, Any] = [ 0X6A09E667, 0XBB67AE85, 0X3C6EF372, 0XA54FF53A, 0X510E527F, 0X9B05688C, 0X1F83D9AB, 0X5BE0CD19, ] # Initialize round constants lowercase__ : Tuple = [ 0X428A2F98, 0X71374491, 0XB5C0FBCF, 0XE9B5DBA5, 0X3956C25B, 0X59F111F1, 0X923F82A4, 0XAB1C5ED5, 0XD807AA98, 0X12835B01, 0X243185BE, 0X550C7DC3, 0X72BE5D74, 0X80DEB1FE, 0X9BDC06A7, 0XC19BF174, 0XE49B69C1, 0XEFBE4786, 0X0FC19DC6, 0X240CA1CC, 0X2DE92C6F, 0X4A7484AA, 0X5CB0A9DC, 0X76F988DA, 0X983E5152, 0XA831C66D, 0XB00327C8, 0XBF597FC7, 0XC6E00BF3, 0XD5A79147, 0X06CA6351, 0X14292967, 0X27B70A85, 0X2E1B2138, 0X4D2C6DFC, 0X53380D13, 0X650A7354, 0X766A0ABB, 0X81C2C92E, 0X92722C85, 0XA2BFE8A1, 0XA81A664B, 0XC24B8B70, 0XC76C51A3, 0XD192E819, 0XD6990624, 0XF40E3585, 0X106AA070, 0X19A4C116, 0X1E376C08, 0X2748774C, 0X34B0BCB5, 0X391C0CB3, 0X4ED8AA4A, 0X5B9CCA4F, 0X682E6FF3, 0X748F82EE, 0X78A5636F, 0X84C87814, 0X8CC70208, 0X90BEFFFA, 0XA4506CEB, 0XBEF9A3F7, 0XC67178F2, ] lowercase__ : str = self.preprocessing(self.data ) self.final_hash() @staticmethod def _lowerCAmelCase( __lowerCAmelCase ) -> bytes: lowercase__ : Any = b'''\x80''' + (b'''\x00''' * (63 - (len(__lowerCAmelCase ) + 8) % 64)) lowercase__ : List[Any] = struct.pack('''>Q''' , (len(__lowerCAmelCase ) * 8) ) return data + padding + big_endian_integer def _lowerCAmelCase( self ) -> None: # Convert into blocks of 64 bytes lowercase__ : Tuple = [ self.preprocessed_data[x : x + 64] for x in range(0 , len(self.preprocessed_data ) , 64 ) ] for block in self.blocks: # Convert the given block into a list of 4 byte integers lowercase__ : Optional[Any] = list(struct.unpack('''>16L''' , __lowerCAmelCase ) ) # add 48 0-ed integers words += [0] * 48 lowercase__ , lowercase__ , lowercase__ , lowercase__ , lowercase__ , lowercase__ , lowercase__ , lowercase__ : Tuple = self.hashes for index in range(0 , 64 ): if index > 15: # modify the zero-ed indexes at the end of the array lowercase__ : str = ( self.ror(words[index - 15] , 7 ) ^ self.ror(words[index - 15] , 18 ) ^ (words[index - 15] >> 3) ) lowercase__ : Any = ( self.ror(words[index - 2] , 17 ) ^ self.ror(words[index - 2] , 19 ) ^ (words[index - 2] >> 10) ) lowercase__ : Dict = ( words[index - 16] + sa + words[index - 7] + sa ) % 0X100000000 # Compression lowercase__ : Optional[Any] = self.ror(__lowerCAmelCase , 6 ) ^ self.ror(__lowerCAmelCase , 11 ) ^ self.ror(__lowerCAmelCase , 25 ) lowercase__ : Dict = (e & f) ^ ((~e & 0XFFFFFFFF) & g) lowercase__ : Optional[Any] = ( h + sa + ch + self.round_constants[index] + words[index] ) % 0X100000000 lowercase__ : Union[str, Any] = self.ror(__lowerCAmelCase , 2 ) ^ self.ror(__lowerCAmelCase , 13 ) ^ self.ror(__lowerCAmelCase , 22 ) lowercase__ : int = (a & b) ^ (a & c) ^ (b & c) lowercase__ : Tuple = (sa + maj) % 0X100000000 lowercase__ , lowercase__ , lowercase__ , lowercase__ , lowercase__ , lowercase__ , lowercase__ , lowercase__ : Tuple = ( g, f, e, ((d + tempa) % 0X100000000), c, b, a, ((tempa + tempa) % 0X100000000), ) lowercase__ : Tuple = [a, b, c, d, e, f, g, h] # Modify final values lowercase__ : List[Any] = [ ((element + mutated_hash_values[index]) % 0X100000000) for index, element in enumerate(self.hashes ) ] lowercase__ : Tuple = ''''''.join([hex(__lowerCAmelCase )[2:].zfill(8 ) for value in self.hashes] ) def _lowerCAmelCase( self , __lowerCAmelCase , __lowerCAmelCase ) -> int: return 0XFFFFFFFF & (value << (32 - rotations)) | (value >> rotations) class UpperCAmelCase ( unittest.TestCase ): '''simple docstring''' def _lowerCAmelCase( self ) -> None: import hashlib lowercase__ : Union[str, Any] = bytes('''Test String''' , '''utf-8''' ) self.assertEqual(SHAaaa(__lowerCAmelCase ).hash , hashlib.shaaaa(__lowerCAmelCase ).hexdigest() ) def __UpperCamelCase ( ): import doctest doctest.testmod() lowercase__ : str = argparse.ArgumentParser() parser.add_argument( '''-s''' , '''--string''' , dest='''input_string''' , default='''Hello World!! Welcome to Cryptography''' , help='''Hash the string''' , ) parser.add_argument( '''-f''' , '''--file''' , dest='''input_file''' , help='''Hash contents of a file''' ) lowercase__ : Dict = parser.parse_args() lowercase__ : Union[str, Any] = args.input_string # hash input should be a bytestring if args.input_file: with open(args.input_file , '''rb''' ) as f: lowercase__ : List[Any] = f.read() else: lowercase__ : List[Any] = bytes(UpperCAmelCase , '''utf-8''' ) print(SHAaaa(UpperCAmelCase ).hash ) if __name__ == "__main__": main()

'''simple docstring''' import requests __a: str = """https://newsapi.org/v1/articles?source=bbc-news&sortBy=top&apiKey=""" def __UpperCamelCase ( UpperCAmelCase ): # fetching a list of articles in json format lowercase__ : Optional[Any] = requests.get(_NEWS_API + bbc_news_api_key ).json() # each article in the list is a dict for i, article in enumerate(bbc_news_page['''articles'''] , 1 ): print(F"""{i}.) {article['title']}""" ) if __name__ == "__main__": fetch_bbc_news(bbc_news_api_key="""<Your BBC News API key goes here>""")

"""simple docstring""" from typing import Dict from transformers import EvalPrediction, HfArgumentParser, TrainingArguments, is_torch_available from transformers.testing_utils import ( TestCasePlus, execute_subprocess_async, get_torch_dist_unique_port, require_torch_multi_gpu, require_torch_neuroncore, ) from transformers.training_args import ParallelMode from transformers.utils import logging __UpperCamelCase = logging.get_logger(__name__) if is_torch_available(): import torch from torch import nn from torch.utils.data import Dataset from transformers import Trainer class UpperCamelCase ( lowerCAmelCase__ ): def __init__( self, lowerCAmelCase__ = 101) -> int: snake_case_ = length def __len__( self) -> Optional[Any]: return self.length def __getitem__( self, lowerCAmelCase__) -> int: return i class UpperCamelCase : def __call__( self, lowerCAmelCase__) -> Optional[Any]: return {"input_ids": torch.tensor(lowerCAmelCase__), "labels": torch.tensor(lowerCAmelCase__)} class UpperCamelCase ( nn.Module ): def __init__( self) -> Optional[Any]: super().__init__() # Add some (unused) params otherwise DDP will complain. snake_case_ = nn.Linear(120, 80) def a_ ( self, lowerCAmelCase__, lowerCAmelCase__=None) -> Tuple: if labels is not None: return torch.tensor(0.0, device=input_ids.device), input_ids else: return input_ids class UpperCamelCase ( lowerCAmelCase__ ): @require_torch_neuroncore def a_ ( self) -> Any: snake_case_ = f'--nproc_per_node=2\n --master_port={get_torch_dist_unique_port()}\n {self.test_file_dir}/test_trainer_distributed.py\n '.split() snake_case_ = self.get_auto_remove_tmp_dir() snake_case_ = f'--output_dir {output_dir}'.split() snake_case_ = ['torchrun'] + distributed_args + args execute_subprocess_async(lowerCAmelCase__, env=self.get_env()) # successful return here == success - any errors would have caused an error in the sub-call class UpperCamelCase ( lowerCAmelCase__ ): @require_torch_multi_gpu def a_ ( self) -> Any: snake_case_ = f'--nproc_per_node={torch.cuda.device_count()}\n --master_port={get_torch_dist_unique_port()}\n {self.test_file_dir}/test_trainer_distributed.py\n '.split() snake_case_ = self.get_auto_remove_tmp_dir() snake_case_ = f'--output_dir {output_dir}'.split() snake_case_ = ['torchrun'] + distributed_args + args execute_subprocess_async(lowerCAmelCase__, env=self.get_env()) # successful return here == success - any errors would have caused an error in the sub-call if __name__ == "__main__": # The script below is meant to be run under torch.distributed, on a machine with multiple GPUs: # # PYTHONPATH="src" python -m torch.distributed.run --nproc_per_node 2 --output_dir output_dir ./tests/test_trainer_distributed.py __UpperCamelCase = HfArgumentParser((TrainingArguments,)) __UpperCamelCase = parser.parse_args_into_dataclasses()[0] logger.warning( F"""Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}, """ F"""distributed training: {training_args.parallel_mode != ParallelMode.NOT_DISTRIBUTED}""" ) # Essentially, what we want to verify in the distributed case is that we get all samples back, # in the right order. (this is crucial for prediction for instance) for dataset_length in [101, 40, 7]: __UpperCamelCase = DummyDataset(dataset_length) def UpperCAmelCase ( UpperCAmelCase ) -> Dict: snake_case_ = list(range(len(UpperCAmelCase ) ) ) snake_case_ = p.predictions.tolist() == sequential and p.label_ids.tolist() == sequential if not success and training_args.local_rank == 0: logger.warning( 'Predictions and/or labels do not match expected results:\n - predictions: ' f'{p.predictions.tolist()}\n - labels: {p.label_ids.tolist()}\n - expected: {sequential}' ) return {"success": success} __UpperCamelCase = Trainer( model=DummyModel(), args=training_args, data_collator=DummyDataCollator(), eval_dataset=dataset, compute_metrics=compute_metrics, ) __UpperCamelCase = trainer.evaluate() logger.info(metrics) if metrics["eval_success"] is not True: logger.error(metrics) exit(1) __UpperCamelCase = trainer.predict(dataset) logger.info(p.metrics) if p.metrics["test_success"] is not True: logger.error(p.metrics) exit(1) __UpperCamelCase = 2 __UpperCamelCase = trainer.evaluate() logger.info(metrics) if metrics["eval_success"] is not True: logger.error(metrics) exit(1) __UpperCamelCase = trainer.predict(dataset) logger.info(p.metrics) if p.metrics["test_success"] is not True: logger.error(p.metrics) exit(1) __UpperCamelCase = None

"""simple docstring""" import argparse import requests import torch from PIL import Image from transformers import CLIPProcessor, GroupViTConfig, GroupViTModel def UpperCAmelCase ( UpperCAmelCase ) -> Dict: # vision encoder if "img_encoder.pos_embed" in name: snake_case_ = name.replace('img_encoder.pos_embed' , 'vision_model.embeddings.position_embeddings' ) if "img_encoder.patch_embed.proj" in name: snake_case_ = name.replace('img_encoder.patch_embed.proj' , 'vision_model.embeddings.patch_embeddings.projection' ) if "img_encoder.patch_embed.norm" in name: snake_case_ = name.replace('img_encoder.patch_embed.norm' , 'vision_model.embeddings.layernorm' ) if "img_encoder.layers" in name: snake_case_ = name.replace('img_encoder.layers' , 'vision_model.encoder.stages' ) if "blocks" in name and "res" not in name: snake_case_ = name.replace('blocks' , 'layers' ) if "attn" in name and "pre_assign" not in name: snake_case_ = name.replace('attn' , 'self_attn' ) if "proj" in name and "self_attn" in name and "text" not in name: snake_case_ = name.replace('proj' , 'out_proj' ) if "pre_assign_attn.attn.proj" in name: snake_case_ = name.replace('pre_assign_attn.attn.proj' , 'pre_assign_attn.attn.out_proj' ) if "norm1" in name: snake_case_ = name.replace('norm1' , 'layer_norm1' ) if "norm2" in name and "pre_assign" not in name: snake_case_ = name.replace('norm2' , 'layer_norm2' ) if "img_encoder.norm" in name: snake_case_ = name.replace('img_encoder.norm' , 'vision_model.layernorm' ) # text encoder if "text_encoder.token_embedding" in name: snake_case_ = name.replace('text_encoder.token_embedding' , 'text_model.embeddings.token_embedding' ) if "text_encoder.positional_embedding" in name: snake_case_ = name.replace('text_encoder.positional_embedding' , 'text_model.embeddings.position_embedding.weight' ) if "text_encoder.transformer.resblocks." in name: snake_case_ = name.replace('text_encoder.transformer.resblocks.' , 'text_model.encoder.layers.' ) if "ln_1" in name: snake_case_ = name.replace('ln_1' , 'layer_norm1' ) if "ln_2" in name: snake_case_ = name.replace('ln_2' , 'layer_norm2' ) if "c_fc" in name: snake_case_ = name.replace('c_fc' , 'fc1' ) if "c_proj" in name: snake_case_ = name.replace('c_proj' , 'fc2' ) if "text_encoder" in name: snake_case_ = name.replace('text_encoder' , 'text_model' ) if "ln_final" in name: snake_case_ = name.replace('ln_final' , 'final_layer_norm' ) # projection layers if "img_projector.linear_hidden." in name: snake_case_ = name.replace('img_projector.linear_hidden.' , 'visual_projection.' ) if "img_projector.linear_out." in name: snake_case_ = name.replace('img_projector.linear_out.' , 'visual_projection.3.' ) if "text_projector.linear_hidden" in name: snake_case_ = name.replace('text_projector.linear_hidden' , 'text_projection' ) if "text_projector.linear_out" in name: snake_case_ = name.replace('text_projector.linear_out' , 'text_projection.3' ) return name def UpperCAmelCase ( UpperCAmelCase , UpperCAmelCase ) -> Optional[Any]: for key in orig_state_dict.copy().keys(): snake_case_ = orig_state_dict.pop(UpperCAmelCase ) if "qkv" in key: # weights and biases of the key, value and query projections of vision encoder's attention layers require special treatment: # we need to split them up into separate matrices/vectors snake_case_ = key.split('.' ) snake_case_ , snake_case_ = int(key_split[2] ), int(key_split[4] ) snake_case_ = config.vision_config.hidden_size if "weight" in key: snake_case_ = val[:dim, :] snake_case_ = val[dim : dim * 2, :] snake_case_ = val[-dim:, :] else: snake_case_ = val[:dim] snake_case_ = val[dim : dim * 2] snake_case_ = val[-dim:] elif "in_proj" in key: # weights and biases of the key, value and query projections of text encoder's attention layers require special treatment: # we need to split them up into separate matrices/vectors snake_case_ = key.split('.' ) snake_case_ = int(key_split[3] ) snake_case_ = config.text_config.hidden_size if "weight" in key: snake_case_ = val[:dim, :] snake_case_ = val[ dim : dim * 2, : ] snake_case_ = val[-dim:, :] else: snake_case_ = val[:dim] snake_case_ = val[dim : dim * 2] snake_case_ = val[-dim:] else: snake_case_ = rename_key(UpperCAmelCase ) # squeeze if necessary if ( "text_projection.0" in new_name or "text_projection.3" in new_name or "visual_projection.0" in new_name or "visual_projection.3" in new_name ): snake_case_ = val.squeeze_() else: snake_case_ = val return orig_state_dict def UpperCAmelCase ( ) -> Any: snake_case_ = 'http://images.cocodataset.org/val2017/000000039769.jpg' snake_case_ = Image.open(requests.get(UpperCAmelCase , stream=UpperCAmelCase ).raw ) return im @torch.no_grad() def UpperCAmelCase ( UpperCAmelCase , UpperCAmelCase , UpperCAmelCase="groupvit-gcc-yfcc" , UpperCAmelCase=False ) -> int: snake_case_ = GroupViTConfig() snake_case_ = GroupViTModel(UpperCAmelCase ).eval() snake_case_ = torch.load(UpperCAmelCase , map_location='cpu' )['model'] snake_case_ = convert_state_dict(UpperCAmelCase , UpperCAmelCase ) snake_case_ , snake_case_ = model.load_state_dict(UpperCAmelCase , strict=UpperCAmelCase ) assert missing_keys == ["text_model.embeddings.position_ids"] assert (unexpected_keys == ["multi_label_logit_scale"]) or (len(UpperCAmelCase ) == 0) # verify result snake_case_ = CLIPProcessor.from_pretrained('openai/clip-vit-base-patch32' ) snake_case_ = prepare_img() snake_case_ = processor(text=['a photo of a cat', 'a photo of a dog'] , images=UpperCAmelCase , padding=UpperCAmelCase , return_tensors='pt' ) with torch.no_grad(): snake_case_ = model(**UpperCAmelCase ) if model_name == "groupvit-gcc-yfcc": snake_case_ = torch.tensor([[13.3_523, 6.3_629]] ) elif model_name == "groupvit-gcc-redcaps": snake_case_ = torch.tensor([[16.1_873, 8.6_230]] ) else: raise ValueError(f'Model name {model_name} not supported.' ) assert torch.allclose(outputs.logits_per_image , UpperCAmelCase , atol=1e-3 ) processor.save_pretrained(UpperCAmelCase ) model.save_pretrained(UpperCAmelCase ) print('Successfully saved processor and model to' , UpperCAmelCase ) if push_to_hub: print('Pushing to the hub...' ) processor.push_to_hub(UpperCAmelCase , organization='nielsr' ) model.push_to_hub(UpperCAmelCase , organization='nielsr' ) if __name__ == "__main__": __UpperCamelCase = argparse.ArgumentParser() parser.add_argument( '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to dump the processor and PyTorch model.''' ) parser.add_argument('''--checkpoint_path''', default=None, type=str, help='''Path to GroupViT checkpoint''') parser.add_argument( '''--model_name''', default='''groupvit-gccy-fcc''', type=str, help='''Name of the model. Expecting either \'groupvit-gcc-yfcc\' or \'groupvit-gcc-redcaps\'''', ) parser.add_argument( '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model and processor to the 🤗 hub using the provided `model_name`.''', ) __UpperCamelCase = parser.parse_args() convert_groupvit_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub)

"""simple docstring""" import importlib import inspect import json import os import re import shutil import sys from pathlib import Path from typing import Dict, Optional, Union from urllib import request from huggingface_hub import HfFolder, cached_download, hf_hub_download, model_info from packaging import version from .. import __version__ from . import DIFFUSERS_DYNAMIC_MODULE_NAME, HF_MODULES_CACHE, logging _lowercase = ( '''https://raw.githubusercontent.com/huggingface/diffusers/{revision}/examples/community/{pipeline}.py''' ) _lowercase = logging.get_logger(__name__) # pylint: disable=invalid-name def _snake_case ( ): A = 'https://pypi.org/pypi/diffusers/json' A = json.loads(request.urlopen(snake_case__ ).read() )['releases'].keys() return sorted(snake_case__ , key=lambda snake_case__ : version.Version(snake_case__ ) ) def _snake_case ( ): # This function has already been executed if HF_MODULES_CACHE already is in the Python path. if HF_MODULES_CACHE in sys.path: return sys.path.append(snake_case__ ) os.makedirs(snake_case__ , exist_ok=snake_case__ ) A = Path(snake_case__ ) / '__init__.py' if not init_path.exists(): init_path.touch() def _snake_case ( snake_case__ : Union[str, os.PathLike] ): init_hf_modules() A = Path(snake_case__ ) / name # If the parent module does not exist yet, recursively create it. if not dynamic_module_path.parent.exists(): create_dynamic_module(dynamic_module_path.parent ) os.makedirs(snake_case__ , exist_ok=snake_case__ ) A = dynamic_module_path / '__init__.py' if not init_path.exists(): init_path.touch() def _snake_case ( snake_case__ : Union[str, Any] ): with open(snake_case__ , 'r' , encoding='utf-8' ) as f: A = f.read() # Imports of the form `import .xxx` A = re.findall('^\s*import\s+\.(\S+)\s*$' , snake_case__ , flags=re.MULTILINE ) # Imports of the form `from .xxx import yyy` relative_imports += re.findall('^\s*from\s+\.(\S+)\s+import' , snake_case__ , flags=re.MULTILINE ) # Unique-ify return list(set(snake_case__ ) ) def _snake_case ( snake_case__ : str ): A = False A = [module_file] A = [] # Let's recurse through all relative imports while not no_change: A = [] for f in files_to_check: new_imports.extend(get_relative_imports(snake_case__ ) ) A = Path(snake_case__ ).parent A = [str(module_path / m ) for m in new_imports] A = [f for f in new_import_files if f not in all_relative_imports] A = [F'{f}.py' for f in new_import_files] A = len(snake_case__ ) == 0 all_relative_imports.extend(snake_case__ ) return all_relative_imports def _snake_case ( snake_case__ : int ): with open(snake_case__ , 'r' , encoding='utf-8' ) as f: A = f.read() # Imports of the form `import xxx` A = re.findall('^\s*import\s+(\S+)\s*$' , snake_case__ , flags=re.MULTILINE ) # Imports of the form `from xxx import yyy` imports += re.findall('^\s*from\s+(\S+)\s+import' , snake_case__ , flags=re.MULTILINE ) # Only keep the top-level module A = [imp.split('.' )[0] for imp in imports if not imp.startswith('.' )] # Unique-ify and test we got them all A = list(set(snake_case__ ) ) A = [] for imp in imports: try: importlib.import_module(snake_case__ ) except ImportError: missing_packages.append(snake_case__ ) if len(snake_case__ ) > 0: raise ImportError( 'This modeling file requires the following packages that were not found in your environment: ' F'{", ".join(snake_case__ )}. Run `pip install {" ".join(snake_case__ )}`' ) return get_relative_imports(snake_case__ ) def _snake_case ( snake_case__ : Tuple , snake_case__ : Optional[Any] ): A = module_path.replace(os.path.sep , '.' ) A = importlib.import_module(snake_case__ ) if class_name is None: return find_pipeline_class(snake_case__ ) return getattr(snake_case__ , snake_case__ ) def _snake_case ( snake_case__ : List[str] ): from ..pipelines import DiffusionPipeline A = dict(inspect.getmembers(snake_case__ , inspect.isclass ) ) A = None for cls_name, cls in cls_members.items(): if ( cls_name != DiffusionPipeline.__name__ and issubclass(cls , snake_case__ ) and cls.__module__.split('.' )[0] != "diffusers" ): if pipeline_class is not None: raise ValueError( F'Multiple classes that inherit from {DiffusionPipeline.__name__} have been found:' F' {pipeline_class.__name__}, and {cls_name}. Please make sure to define only one in' F' {loaded_module}.' ) A = cls return pipeline_class def _snake_case ( snake_case__ : Union[str, os.PathLike] , snake_case__ : str , snake_case__ : Optional[Union[str, os.PathLike]] = None , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : Optional[Dict[str, str]] = None , snake_case__ : Optional[Union[bool, str]] = None , snake_case__ : Optional[str] = None , snake_case__ : bool = False , ): A = str(snake_case__ ) A = os.path.join(snake_case__ , snake_case__ ) if os.path.isfile(snake_case__ ): A = module_file_or_url A = 'local' elif pretrained_model_name_or_path.count('/' ) == 0: A = get_diffusers_versions() # cut ".dev0" A = 'v' + '.'.join(__version__.split('.' )[:3] ) # retrieve github version that matches if revision is None: A = latest_version if latest_version[1:] in available_versions else 'main' logger.info(F'Defaulting to latest_version: {revision}.' ) elif revision in available_versions: A = F'v{revision}' elif revision == "main": A = revision else: raise ValueError( F'`custom_revision`: {revision} does not exist. Please make sure to choose one of' F' {", ".join(available_versions + ["main"] )}.' ) # community pipeline on GitHub A = COMMUNITY_PIPELINES_URL.format(revision=snake_case__ , pipeline=snake_case__ ) try: A = cached_download( snake_case__ , cache_dir=snake_case__ , force_download=snake_case__ , proxies=snake_case__ , resume_download=snake_case__ , local_files_only=snake_case__ , use_auth_token=snake_case__ , ) A = 'git' A = pretrained_model_name_or_path + '.py' except EnvironmentError: logger.error(F'Could not locate the {module_file} inside {pretrained_model_name_or_path}.' ) raise else: try: # Load from URL or cache if already cached A = hf_hub_download( snake_case__ , snake_case__ , cache_dir=snake_case__ , force_download=snake_case__ , proxies=snake_case__ , resume_download=snake_case__ , local_files_only=snake_case__ , use_auth_token=snake_case__ , ) A = os.path.join('local' , '--'.join(pretrained_model_name_or_path.split('/' ) ) ) except EnvironmentError: logger.error(F'Could not locate the {module_file} inside {pretrained_model_name_or_path}.' ) raise # Check we have all the requirements in our environment A = check_imports(snake_case__ ) # Now we move the module inside our cached dynamic modules. A = DIFFUSERS_DYNAMIC_MODULE_NAME + os.path.sep + submodule create_dynamic_module(snake_case__ ) A = Path(snake_case__ ) / full_submodule if submodule == "local" or submodule == "git": # We always copy local files (we could hash the file to see if there was a change, and give them the name of # that hash, to only copy when there is a modification but it seems overkill for now). # The only reason we do the copy is to avoid putting too many folders in sys.path. shutil.copy(snake_case__ , submodule_path / module_file ) for module_needed in modules_needed: A = F'{module_needed}.py' shutil.copy(os.path.join(snake_case__ , snake_case__ ) , submodule_path / module_needed ) else: # Get the commit hash # TODO: we will get this info in the etag soon, so retrieve it from there and not here. if isinstance(snake_case__ , snake_case__ ): A = use_auth_token elif use_auth_token is True: A = HfFolder.get_token() else: A = None A = model_info(snake_case__ , revision=snake_case__ , token=snake_case__ ).sha # The module file will end up being placed in a subfolder with the git hash of the repo. This way we get the # benefit of versioning. A = submodule_path / commit_hash A = full_submodule + os.path.sep + commit_hash create_dynamic_module(snake_case__ ) if not (submodule_path / module_file).exists(): shutil.copy(snake_case__ , submodule_path / module_file ) # Make sure we also have every file with relative for module_needed in modules_needed: if not (submodule_path / module_needed).exists(): get_cached_module_file( snake_case__ , F'{module_needed}.py' , cache_dir=snake_case__ , force_download=snake_case__ , resume_download=snake_case__ , proxies=snake_case__ , use_auth_token=snake_case__ , revision=snake_case__ , local_files_only=snake_case__ , ) return os.path.join(snake_case__ , snake_case__ ) def _snake_case ( snake_case__ : Union[str, os.PathLike] , snake_case__ : str , snake_case__ : Optional[str] = None , snake_case__ : Optional[Union[str, os.PathLike]] = None , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : Optional[Dict[str, str]] = None , snake_case__ : Optional[Union[bool, str]] = None , snake_case__ : Optional[str] = None , snake_case__ : bool = False , **snake_case__ : List[Any] , ): A = get_cached_module_file( snake_case__ , snake_case__ , cache_dir=snake_case__ , force_download=snake_case__ , resume_download=snake_case__ , proxies=snake_case__ , use_auth_token=snake_case__ , revision=snake_case__ , local_files_only=snake_case__ , ) return get_class_in_module(snake_case__ , final_module.replace('.py' , '' ) )

"""simple docstring""" from __future__ import annotations __magic_name__ = [-10, -5, 0, 5, 5.1, 11, 13, 21, 3, 4, -21, -10, -5, -1, 0] __magic_name__ = [-5, 0, 5, 5.1, 11, 13, 21, -1, 4, -1, -10, -5, -1, 0, -1] def _lowerCAmelCase ( UpperCamelCase_ ): __SCREAMING_SNAKE_CASE = [] __SCREAMING_SNAKE_CASE = len(UpperCamelCase_ ) for i in range(UpperCamelCase_ ): __SCREAMING_SNAKE_CASE = -1 for j in range(i + 1 , UpperCamelCase_ ): if arr[i] < arr[j]: __SCREAMING_SNAKE_CASE = arr[j] break result.append(UpperCamelCase_ ) return result def _lowerCAmelCase ( UpperCamelCase_ ): __SCREAMING_SNAKE_CASE = [] for i, outer in enumerate(UpperCamelCase_ ): __SCREAMING_SNAKE_CASE = -1 for inner in arr[i + 1 :]: if outer < inner: __SCREAMING_SNAKE_CASE = inner break result.append(UpperCamelCase_ ) return result def _lowerCAmelCase ( UpperCamelCase_ ): __SCREAMING_SNAKE_CASE = len(UpperCamelCase_ ) __SCREAMING_SNAKE_CASE = [] __SCREAMING_SNAKE_CASE = [-1] * arr_size for index in reversed(range(UpperCamelCase_ ) ): if stack: while stack[-1] <= arr[index]: stack.pop() if not stack: break if stack: __SCREAMING_SNAKE_CASE = stack[-1] stack.append(arr[index] ) return result if __name__ == "__main__": from doctest import testmod from timeit import timeit testmod() print(next_greatest_element_slow(arr)) print(next_greatest_element_fast(arr)) print(next_greatest_element(arr)) __magic_name__ = ( "from __main__ import arr, next_greatest_element_slow, " "next_greatest_element_fast, next_greatest_element" ) print( "next_greatest_element_slow():", timeit("next_greatest_element_slow(arr)", setup=setup), ) print( "next_greatest_element_fast():", timeit("next_greatest_element_fast(arr)", setup=setup), ) print( " next_greatest_element():", timeit("next_greatest_element(arr)", setup=setup), )

'''simple docstring''' from __future__ import annotations import inspect import unittest import numpy as np from transformers import ResNetConfig from transformers.testing_utils import require_tf, require_vision, slow from transformers.utils import cached_property, is_tf_available, is_vision_available from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import tensorflow as tf from transformers import TFResNetForImageClassification, TFResNetModel from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import AutoImageProcessor class lowerCAmelCase__ : """simple docstring""" def __init__( self : Tuple , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Optional[int]=3 , __SCREAMING_SNAKE_CASE : str=32 , __SCREAMING_SNAKE_CASE : Any=3 , __SCREAMING_SNAKE_CASE : str=10 , __SCREAMING_SNAKE_CASE : Any=[10, 20, 30, 40] , __SCREAMING_SNAKE_CASE : Optional[int]=[1, 1, 2, 1] , __SCREAMING_SNAKE_CASE : str=True , __SCREAMING_SNAKE_CASE : int=True , __SCREAMING_SNAKE_CASE : Tuple="relu" , __SCREAMING_SNAKE_CASE : str=3 , __SCREAMING_SNAKE_CASE : Union[str, Any]=None , ) -> str: """simple docstring""" __SCREAMING_SNAKE_CASE = parent __SCREAMING_SNAKE_CASE = batch_size __SCREAMING_SNAKE_CASE = image_size __SCREAMING_SNAKE_CASE = num_channels __SCREAMING_SNAKE_CASE = embeddings_size __SCREAMING_SNAKE_CASE = hidden_sizes __SCREAMING_SNAKE_CASE = depths __SCREAMING_SNAKE_CASE = is_training __SCREAMING_SNAKE_CASE = use_labels __SCREAMING_SNAKE_CASE = hidden_act __SCREAMING_SNAKE_CASE = num_labels __SCREAMING_SNAKE_CASE = scope __SCREAMING_SNAKE_CASE = len(__SCREAMING_SNAKE_CASE ) def UpperCAmelCase__ ( self : Union[str, Any] ) -> int: """simple docstring""" __SCREAMING_SNAKE_CASE = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) __SCREAMING_SNAKE_CASE = None if self.use_labels: __SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.num_labels ) __SCREAMING_SNAKE_CASE = self.get_config() return config, pixel_values, labels def UpperCAmelCase__ ( self : Union[str, Any] ) -> List[Any]: """simple docstring""" return ResNetConfig( num_channels=self.num_channels , embeddings_size=self.embeddings_size , hidden_sizes=self.hidden_sizes , depths=self.depths , hidden_act=self.hidden_act , num_labels=self.num_labels , image_size=self.image_size , ) def UpperCAmelCase__ ( self : Dict , __SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : Optional[Any] ) -> Union[str, Any]: """simple docstring""" __SCREAMING_SNAKE_CASE = TFResNetModel(config=__SCREAMING_SNAKE_CASE ) __SCREAMING_SNAKE_CASE = model(__SCREAMING_SNAKE_CASE ) # expected last hidden states: B, C, H // 32, W // 32 self.parent.assertEqual( result.last_hidden_state.shape , (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32) , ) def UpperCAmelCase__ ( self : int , __SCREAMING_SNAKE_CASE : List[Any] , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Dict ) -> int: """simple docstring""" __SCREAMING_SNAKE_CASE = self.num_labels __SCREAMING_SNAKE_CASE = TFResNetForImageClassification(__SCREAMING_SNAKE_CASE ) __SCREAMING_SNAKE_CASE = model(__SCREAMING_SNAKE_CASE , labels=__SCREAMING_SNAKE_CASE ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def UpperCAmelCase__ ( self : str ) -> Dict: """simple docstring""" __SCREAMING_SNAKE_CASE = self.prepare_config_and_inputs() __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE = config_and_inputs __SCREAMING_SNAKE_CASE = {"""pixel_values""": pixel_values} return config, inputs_dict @require_tf class lowerCAmelCase__ ( a , a , unittest.TestCase ): """simple docstring""" lowerCAmelCase__ = (TFResNetModel, TFResNetForImageClassification) if is_tf_available() else () lowerCAmelCase__ = ( {"feature-extraction": TFResNetModel, "image-classification": TFResNetForImageClassification} if is_tf_available() else {} ) lowerCAmelCase__ = False lowerCAmelCase__ = False lowerCAmelCase__ = False lowerCAmelCase__ = False lowerCAmelCase__ = False def UpperCAmelCase__ ( self : Dict ) -> Tuple: """simple docstring""" __SCREAMING_SNAKE_CASE = TFResNetModelTester(self ) __SCREAMING_SNAKE_CASE = ConfigTester(self , config_class=__SCREAMING_SNAKE_CASE , has_text_modality=__SCREAMING_SNAKE_CASE ) def UpperCAmelCase__ ( self : Optional[int] ) -> 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 UpperCAmelCase__ ( self : Any ) -> int: """simple docstring""" return @unittest.skip(reason="""ResNet does not use inputs_embeds""" ) def UpperCAmelCase__ ( self : int ) -> str: """simple docstring""" pass @unittest.skip(reason="""ResNet does not support input and output embeddings""" ) def UpperCAmelCase__ ( self : Tuple ) -> List[Any]: """simple docstring""" pass def UpperCAmelCase__ ( self : int ) -> Optional[Any]: """simple docstring""" __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: __SCREAMING_SNAKE_CASE = model_class(__SCREAMING_SNAKE_CASE ) __SCREAMING_SNAKE_CASE = inspect.signature(model.call ) # signature.parameters is an OrderedDict => so arg_names order is deterministic __SCREAMING_SNAKE_CASE = [*signature.parameters.keys()] __SCREAMING_SNAKE_CASE = ["""pixel_values"""] self.assertListEqual(arg_names[:1] , __SCREAMING_SNAKE_CASE ) def UpperCAmelCase__ ( self : Union[str, Any] ) -> Union[str, Any]: """simple docstring""" __SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE ) def UpperCAmelCase__ ( self : Union[str, Any] ) -> int: """simple docstring""" def check_hidden_states_output(__SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : Optional[int] ): __SCREAMING_SNAKE_CASE = model_class(__SCREAMING_SNAKE_CASE ) __SCREAMING_SNAKE_CASE = model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) ) __SCREAMING_SNAKE_CASE = outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states __SCREAMING_SNAKE_CASE = self.model_tester.num_stages self.assertEqual(len(__SCREAMING_SNAKE_CASE ) , expected_num_stages + 1 ) # ResNet's feature maps are of shape (batch_size, num_channels, height, width) self.assertListEqual( list(hidden_states[0].shape[-2:] ) , [self.model_tester.image_size // 4, self.model_tester.image_size // 4] , ) __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() __SCREAMING_SNAKE_CASE = ["""basic""", """bottleneck"""] for model_class in self.all_model_classes: for layer_type in layers_type: __SCREAMING_SNAKE_CASE = layer_type __SCREAMING_SNAKE_CASE = True check_hidden_states_output(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] __SCREAMING_SNAKE_CASE = True check_hidden_states_output(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) def UpperCAmelCase__ ( self : Optional[int] ) -> List[str]: """simple docstring""" __SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*__SCREAMING_SNAKE_CASE ) @slow def UpperCAmelCase__ ( self : int ) -> Dict: """simple docstring""" for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: __SCREAMING_SNAKE_CASE = TFResNetModel.from_pretrained(__SCREAMING_SNAKE_CASE ) self.assertIsNotNone(__SCREAMING_SNAKE_CASE ) def a__ ( ): """simple docstring""" __SCREAMING_SNAKE_CASE = Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" ) return image @require_tf @require_vision class lowerCAmelCase__ ( unittest.TestCase ): """simple docstring""" @cached_property def UpperCAmelCase__ ( self : List[Any] ) -> List[Any]: """simple docstring""" return ( AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0] ) if is_vision_available() else None ) @slow def UpperCAmelCase__ ( self : str ) -> List[Any]: """simple docstring""" __SCREAMING_SNAKE_CASE = TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0] ) __SCREAMING_SNAKE_CASE = self.default_image_processor __SCREAMING_SNAKE_CASE = prepare_img() __SCREAMING_SNAKE_CASE = image_processor(images=__SCREAMING_SNAKE_CASE , return_tensors="""tf""" ) # forward pass __SCREAMING_SNAKE_CASE = model(**__SCREAMING_SNAKE_CASE ) # verify the logits __SCREAMING_SNAKE_CASE = tf.TensorShape((1, 1_000) ) self.assertEqual(outputs.logits.shape , __SCREAMING_SNAKE_CASE ) __SCREAMING_SNAKE_CASE = tf.constant([-11.1069, -9.7877, -8.3777] ) self.assertTrue(np.allclose(outputs.logits[0, :3].numpy() , __SCREAMING_SNAKE_CASE , atol=1E-4 ) )

'''simple docstring''' import unittest from transformers.testing_utils import CaptureStdout from transformers.tools.python_interpreter import evaluate def a__ ( a__ ): """simple docstring""" return x + 2 class lowerCAmelCase__ ( unittest.TestCase ): """simple docstring""" def UpperCAmelCase__ ( self : Any ) -> Dict: """simple docstring""" __SCREAMING_SNAKE_CASE = """x = 3""" __SCREAMING_SNAKE_CASE = {} __SCREAMING_SNAKE_CASE = evaluate(__SCREAMING_SNAKE_CASE , {} , state=__SCREAMING_SNAKE_CASE ) assert result == 3 self.assertDictEqual(__SCREAMING_SNAKE_CASE , {"""x""": 3} ) __SCREAMING_SNAKE_CASE = """x = y""" __SCREAMING_SNAKE_CASE = {"""y""": 5} __SCREAMING_SNAKE_CASE = evaluate(__SCREAMING_SNAKE_CASE , {} , state=__SCREAMING_SNAKE_CASE ) # evaluate returns the value of the last assignment. assert result == 5 self.assertDictEqual(__SCREAMING_SNAKE_CASE , {"""x""": 5, """y""": 5} ) def UpperCAmelCase__ ( self : Optional[int] ) -> int: """simple docstring""" __SCREAMING_SNAKE_CASE = """y = add_two(x)""" __SCREAMING_SNAKE_CASE = {"""x""": 3} __SCREAMING_SNAKE_CASE = evaluate(__SCREAMING_SNAKE_CASE , {"""add_two""": add_two} , state=__SCREAMING_SNAKE_CASE ) assert result == 5 self.assertDictEqual(__SCREAMING_SNAKE_CASE , {"""x""": 3, """y""": 5} ) # Won't work without the tool with CaptureStdout() as out: __SCREAMING_SNAKE_CASE = evaluate(__SCREAMING_SNAKE_CASE , {} , state=__SCREAMING_SNAKE_CASE ) assert result is None assert "tried to execute add_two" in out.out def UpperCAmelCase__ ( self : str ) -> Optional[Any]: """simple docstring""" __SCREAMING_SNAKE_CASE = """x = 3""" __SCREAMING_SNAKE_CASE = {} __SCREAMING_SNAKE_CASE = evaluate(__SCREAMING_SNAKE_CASE , {} , state=__SCREAMING_SNAKE_CASE ) assert result == 3 self.assertDictEqual(__SCREAMING_SNAKE_CASE , {"""x""": 3} ) def UpperCAmelCase__ ( self : List[str] ) -> List[Any]: """simple docstring""" __SCREAMING_SNAKE_CASE = """test_dict = {'x': x, 'y': add_two(x)}""" __SCREAMING_SNAKE_CASE = {"""x""": 3} __SCREAMING_SNAKE_CASE = evaluate(__SCREAMING_SNAKE_CASE , {"""add_two""": add_two} , state=__SCREAMING_SNAKE_CASE ) self.assertDictEqual(__SCREAMING_SNAKE_CASE , {"""x""": 3, """y""": 5} ) self.assertDictEqual(__SCREAMING_SNAKE_CASE , {"""x""": 3, """test_dict""": {"""x""": 3, """y""": 5}} ) def UpperCAmelCase__ ( self : Optional[Any] ) -> Dict: """simple docstring""" __SCREAMING_SNAKE_CASE = """x = 3\ny = 5""" __SCREAMING_SNAKE_CASE = {} __SCREAMING_SNAKE_CASE = evaluate(__SCREAMING_SNAKE_CASE , {} , state=__SCREAMING_SNAKE_CASE ) # evaluate returns the value of the last assignment. assert result == 5 self.assertDictEqual(__SCREAMING_SNAKE_CASE , {"""x""": 3, """y""": 5} ) def UpperCAmelCase__ ( self : Union[str, Any] ) -> Dict: """simple docstring""" __SCREAMING_SNAKE_CASE = """text = f'This is x: {x}.'""" __SCREAMING_SNAKE_CASE = {"""x""": 3} __SCREAMING_SNAKE_CASE = evaluate(__SCREAMING_SNAKE_CASE , {} , state=__SCREAMING_SNAKE_CASE ) # evaluate returns the value of the last assignment. assert result == "This is x: 3." self.assertDictEqual(__SCREAMING_SNAKE_CASE , {"""x""": 3, """text""": """This is x: 3."""} ) def UpperCAmelCase__ ( self : Dict ) -> Tuple: """simple docstring""" __SCREAMING_SNAKE_CASE = """if x <= 3:\n y = 2\nelse:\n y = 5""" __SCREAMING_SNAKE_CASE = {"""x""": 3} __SCREAMING_SNAKE_CASE = evaluate(__SCREAMING_SNAKE_CASE , {} , state=__SCREAMING_SNAKE_CASE ) # evaluate returns the value of the last assignment. assert result == 2 self.assertDictEqual(__SCREAMING_SNAKE_CASE , {"""x""": 3, """y""": 2} ) __SCREAMING_SNAKE_CASE = {"""x""": 8} __SCREAMING_SNAKE_CASE = evaluate(__SCREAMING_SNAKE_CASE , {} , state=__SCREAMING_SNAKE_CASE ) # evaluate returns the value of the last assignment. assert result == 5 self.assertDictEqual(__SCREAMING_SNAKE_CASE , {"""x""": 8, """y""": 5} ) def UpperCAmelCase__ ( self : Dict ) -> Tuple: """simple docstring""" __SCREAMING_SNAKE_CASE = """test_list = [x, add_two(x)]""" __SCREAMING_SNAKE_CASE = {"""x""": 3} __SCREAMING_SNAKE_CASE = evaluate(__SCREAMING_SNAKE_CASE , {"""add_two""": add_two} , state=__SCREAMING_SNAKE_CASE ) self.assertListEqual(__SCREAMING_SNAKE_CASE , [3, 5] ) self.assertDictEqual(__SCREAMING_SNAKE_CASE , {"""x""": 3, """test_list""": [3, 5]} ) def UpperCAmelCase__ ( self : Tuple ) -> Tuple: """simple docstring""" __SCREAMING_SNAKE_CASE = """y = x""" __SCREAMING_SNAKE_CASE = {"""x""": 3} __SCREAMING_SNAKE_CASE = evaluate(__SCREAMING_SNAKE_CASE , {} , state=__SCREAMING_SNAKE_CASE ) assert result == 3 self.assertDictEqual(__SCREAMING_SNAKE_CASE , {"""x""": 3, """y""": 3} ) def UpperCAmelCase__ ( self : Any ) -> Tuple: """simple docstring""" __SCREAMING_SNAKE_CASE = """test_list = [x, add_two(x)]\ntest_list[1]""" __SCREAMING_SNAKE_CASE = {"""x""": 3} __SCREAMING_SNAKE_CASE = evaluate(__SCREAMING_SNAKE_CASE , {"""add_two""": add_two} , state=__SCREAMING_SNAKE_CASE ) assert result == 5 self.assertDictEqual(__SCREAMING_SNAKE_CASE , {"""x""": 3, """test_list""": [3, 5]} ) __SCREAMING_SNAKE_CASE = """test_dict = {'x': x, 'y': add_two(x)}\ntest_dict['y']""" __SCREAMING_SNAKE_CASE = {"""x""": 3} __SCREAMING_SNAKE_CASE = evaluate(__SCREAMING_SNAKE_CASE , {"""add_two""": add_two} , state=__SCREAMING_SNAKE_CASE ) assert result == 5 self.assertDictEqual(__SCREAMING_SNAKE_CASE , {"""x""": 3, """test_dict""": {"""x""": 3, """y""": 5}} ) def UpperCAmelCase__ ( self : Optional[Any] ) -> Optional[int]: """simple docstring""" __SCREAMING_SNAKE_CASE = """x = 0\nfor i in range(3):\n x = i""" __SCREAMING_SNAKE_CASE = {} __SCREAMING_SNAKE_CASE = evaluate(__SCREAMING_SNAKE_CASE , {"""range""": range} , state=__SCREAMING_SNAKE_CASE ) assert result == 2 self.assertDictEqual(__SCREAMING_SNAKE_CASE , {"""x""": 2, """i""": 2} )

'''simple docstring''' from collections import OrderedDict from ...utils import logging from .auto_factory import _BaseAutoModelClass, _LazyAutoMapping, auto_class_update from .configuration_auto import CONFIG_MAPPING_NAMES a__ : Optional[Any] =logging.get_logger(__name__) a__ : str =OrderedDict( [ # Base model mapping ('''albert''', '''FlaxAlbertModel'''), ('''bart''', '''FlaxBartModel'''), ('''beit''', '''FlaxBeitModel'''), ('''bert''', '''FlaxBertModel'''), ('''big_bird''', '''FlaxBigBirdModel'''), ('''blenderbot''', '''FlaxBlenderbotModel'''), ('''blenderbot-small''', '''FlaxBlenderbotSmallModel'''), ('''clip''', '''FlaxCLIPModel'''), ('''distilbert''', '''FlaxDistilBertModel'''), ('''electra''', '''FlaxElectraModel'''), ('''gpt-sw3''', '''FlaxGPT2Model'''), ('''gpt2''', '''FlaxGPT2Model'''), ('''gpt_neo''', '''FlaxGPTNeoModel'''), ('''gptj''', '''FlaxGPTJModel'''), ('''longt5''', '''FlaxLongT5Model'''), ('''marian''', '''FlaxMarianModel'''), ('''mbart''', '''FlaxMBartModel'''), ('''mt5''', '''FlaxMT5Model'''), ('''opt''', '''FlaxOPTModel'''), ('''pegasus''', '''FlaxPegasusModel'''), ('''regnet''', '''FlaxRegNetModel'''), ('''resnet''', '''FlaxResNetModel'''), ('''roberta''', '''FlaxRobertaModel'''), ('''roberta-prelayernorm''', '''FlaxRobertaPreLayerNormModel'''), ('''roformer''', '''FlaxRoFormerModel'''), ('''t5''', '''FlaxT5Model'''), ('''vision-text-dual-encoder''', '''FlaxVisionTextDualEncoderModel'''), ('''vit''', '''FlaxViTModel'''), ('''wav2vec2''', '''FlaxWav2Vec2Model'''), ('''whisper''', '''FlaxWhisperModel'''), ('''xglm''', '''FlaxXGLMModel'''), ('''xlm-roberta''', '''FlaxXLMRobertaModel'''), ] ) a__ : Any =OrderedDict( [ # Model for pre-training mapping ('''albert''', '''FlaxAlbertForPreTraining'''), ('''bart''', '''FlaxBartForConditionalGeneration'''), ('''bert''', '''FlaxBertForPreTraining'''), ('''big_bird''', '''FlaxBigBirdForPreTraining'''), ('''electra''', '''FlaxElectraForPreTraining'''), ('''longt5''', '''FlaxLongT5ForConditionalGeneration'''), ('''mbart''', '''FlaxMBartForConditionalGeneration'''), ('''mt5''', '''FlaxMT5ForConditionalGeneration'''), ('''roberta''', '''FlaxRobertaForMaskedLM'''), ('''roberta-prelayernorm''', '''FlaxRobertaPreLayerNormForMaskedLM'''), ('''roformer''', '''FlaxRoFormerForMaskedLM'''), ('''t5''', '''FlaxT5ForConditionalGeneration'''), ('''wav2vec2''', '''FlaxWav2Vec2ForPreTraining'''), ('''whisper''', '''FlaxWhisperForConditionalGeneration'''), ('''xlm-roberta''', '''FlaxXLMRobertaForMaskedLM'''), ] ) a__ : Union[str, Any] =OrderedDict( [ # Model for Masked LM mapping ('''albert''', '''FlaxAlbertForMaskedLM'''), ('''bart''', '''FlaxBartForConditionalGeneration'''), ('''bert''', '''FlaxBertForMaskedLM'''), ('''big_bird''', '''FlaxBigBirdForMaskedLM'''), ('''distilbert''', '''FlaxDistilBertForMaskedLM'''), ('''electra''', '''FlaxElectraForMaskedLM'''), ('''mbart''', '''FlaxMBartForConditionalGeneration'''), ('''roberta''', '''FlaxRobertaForMaskedLM'''), ('''roberta-prelayernorm''', '''FlaxRobertaPreLayerNormForMaskedLM'''), ('''roformer''', '''FlaxRoFormerForMaskedLM'''), ('''xlm-roberta''', '''FlaxXLMRobertaForMaskedLM'''), ] ) a__ : Optional[int] =OrderedDict( [ # Model for Seq2Seq Causal LM mapping ('''bart''', '''FlaxBartForConditionalGeneration'''), ('''blenderbot''', '''FlaxBlenderbotForConditionalGeneration'''), ('''blenderbot-small''', '''FlaxBlenderbotSmallForConditionalGeneration'''), ('''encoder-decoder''', '''FlaxEncoderDecoderModel'''), ('''longt5''', '''FlaxLongT5ForConditionalGeneration'''), ('''marian''', '''FlaxMarianMTModel'''), ('''mbart''', '''FlaxMBartForConditionalGeneration'''), ('''mt5''', '''FlaxMT5ForConditionalGeneration'''), ('''pegasus''', '''FlaxPegasusForConditionalGeneration'''), ('''t5''', '''FlaxT5ForConditionalGeneration'''), ] ) a__ : Any =OrderedDict( [ # Model for Image-classsification ('''beit''', '''FlaxBeitForImageClassification'''), ('''regnet''', '''FlaxRegNetForImageClassification'''), ('''resnet''', '''FlaxResNetForImageClassification'''), ('''vit''', '''FlaxViTForImageClassification'''), ] ) a__ : Any =OrderedDict( [ ('''vision-encoder-decoder''', '''FlaxVisionEncoderDecoderModel'''), ] ) a__ : List[str] =OrderedDict( [ # Model for Causal LM mapping ('''bart''', '''FlaxBartForCausalLM'''), ('''bert''', '''FlaxBertForCausalLM'''), ('''big_bird''', '''FlaxBigBirdForCausalLM'''), ('''electra''', '''FlaxElectraForCausalLM'''), ('''gpt-sw3''', '''FlaxGPT2LMHeadModel'''), ('''gpt2''', '''FlaxGPT2LMHeadModel'''), ('''gpt_neo''', '''FlaxGPTNeoForCausalLM'''), ('''gptj''', '''FlaxGPTJForCausalLM'''), ('''opt''', '''FlaxOPTForCausalLM'''), ('''roberta''', '''FlaxRobertaForCausalLM'''), ('''roberta-prelayernorm''', '''FlaxRobertaPreLayerNormForCausalLM'''), ('''xglm''', '''FlaxXGLMForCausalLM'''), ('''xlm-roberta''', '''FlaxXLMRobertaForCausalLM'''), ] ) a__ : Optional[int] =OrderedDict( [ # Model for Sequence Classification mapping ('''albert''', '''FlaxAlbertForSequenceClassification'''), ('''bart''', '''FlaxBartForSequenceClassification'''), ('''bert''', '''FlaxBertForSequenceClassification'''), ('''big_bird''', '''FlaxBigBirdForSequenceClassification'''), ('''distilbert''', '''FlaxDistilBertForSequenceClassification'''), ('''electra''', '''FlaxElectraForSequenceClassification'''), ('''mbart''', '''FlaxMBartForSequenceClassification'''), ('''roberta''', '''FlaxRobertaForSequenceClassification'''), ('''roberta-prelayernorm''', '''FlaxRobertaPreLayerNormForSequenceClassification'''), ('''roformer''', '''FlaxRoFormerForSequenceClassification'''), ('''xlm-roberta''', '''FlaxXLMRobertaForSequenceClassification'''), ] ) a__ : Optional[int] =OrderedDict( [ # Model for Question Answering mapping ('''albert''', '''FlaxAlbertForQuestionAnswering'''), ('''bart''', '''FlaxBartForQuestionAnswering'''), ('''bert''', '''FlaxBertForQuestionAnswering'''), ('''big_bird''', '''FlaxBigBirdForQuestionAnswering'''), ('''distilbert''', '''FlaxDistilBertForQuestionAnswering'''), ('''electra''', '''FlaxElectraForQuestionAnswering'''), ('''mbart''', '''FlaxMBartForQuestionAnswering'''), ('''roberta''', '''FlaxRobertaForQuestionAnswering'''), ('''roberta-prelayernorm''', '''FlaxRobertaPreLayerNormForQuestionAnswering'''), ('''roformer''', '''FlaxRoFormerForQuestionAnswering'''), ('''xlm-roberta''', '''FlaxXLMRobertaForQuestionAnswering'''), ] ) a__ : int =OrderedDict( [ # Model for Token Classification mapping ('''albert''', '''FlaxAlbertForTokenClassification'''), ('''bert''', '''FlaxBertForTokenClassification'''), ('''big_bird''', '''FlaxBigBirdForTokenClassification'''), ('''distilbert''', '''FlaxDistilBertForTokenClassification'''), ('''electra''', '''FlaxElectraForTokenClassification'''), ('''roberta''', '''FlaxRobertaForTokenClassification'''), ('''roberta-prelayernorm''', '''FlaxRobertaPreLayerNormForTokenClassification'''), ('''roformer''', '''FlaxRoFormerForTokenClassification'''), ('''xlm-roberta''', '''FlaxXLMRobertaForTokenClassification'''), ] ) a__ : List[Any] =OrderedDict( [ # Model for Multiple Choice mapping ('''albert''', '''FlaxAlbertForMultipleChoice'''), ('''bert''', '''FlaxBertForMultipleChoice'''), ('''big_bird''', '''FlaxBigBirdForMultipleChoice'''), ('''distilbert''', '''FlaxDistilBertForMultipleChoice'''), ('''electra''', '''FlaxElectraForMultipleChoice'''), ('''roberta''', '''FlaxRobertaForMultipleChoice'''), ('''roberta-prelayernorm''', '''FlaxRobertaPreLayerNormForMultipleChoice'''), ('''roformer''', '''FlaxRoFormerForMultipleChoice'''), ('''xlm-roberta''', '''FlaxXLMRobertaForMultipleChoice'''), ] ) a__ : List[str] =OrderedDict( [ ('''bert''', '''FlaxBertForNextSentencePrediction'''), ] ) a__ : str =OrderedDict( [ ('''speech-encoder-decoder''', '''FlaxSpeechEncoderDecoderModel'''), ('''whisper''', '''FlaxWhisperForConditionalGeneration'''), ] ) a__ : int =OrderedDict( [ ('''whisper''', '''FlaxWhisperForAudioClassification'''), ] ) a__ : Optional[int] =_LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_MAPPING_NAMES) a__ : Tuple =_LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_PRETRAINING_MAPPING_NAMES) a__ : str =_LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_MASKED_LM_MAPPING_NAMES) a__ : Optional[Any] =_LazyAutoMapping( CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING_NAMES ) a__ : Tuple =_LazyAutoMapping( CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING_NAMES ) a__ : Optional[int] =_LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING_NAMES) a__ : Union[str, Any] =_LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_CAUSAL_LM_MAPPING_NAMES) a__ : List[Any] =_LazyAutoMapping( CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING_NAMES ) a__ : List[str] =_LazyAutoMapping( CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING_NAMES ) a__ : Optional[int] =_LazyAutoMapping( CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING_NAMES ) a__ : Dict =_LazyAutoMapping( CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING_NAMES ) a__ : str =_LazyAutoMapping( CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING_NAMES ) a__ : List[Any] =_LazyAutoMapping( CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING_NAMES ) a__ : Union[str, Any] =_LazyAutoMapping( CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING_NAMES ) class snake_case ( _BaseAutoModelClass ): """simple docstring""" SCREAMING_SNAKE_CASE_ : List[str] =FLAX_MODEL_MAPPING a__ : List[Any] =auto_class_update(FlaxAutoModel) class snake_case ( _BaseAutoModelClass ): """simple docstring""" SCREAMING_SNAKE_CASE_ : List[str] =FLAX_MODEL_FOR_PRETRAINING_MAPPING a__ : List[Any] =auto_class_update(FlaxAutoModelForPreTraining, head_doc='''pretraining''') class snake_case ( _BaseAutoModelClass ): """simple docstring""" SCREAMING_SNAKE_CASE_ : str =FLAX_MODEL_FOR_CAUSAL_LM_MAPPING a__ : Optional[int] =auto_class_update(FlaxAutoModelForCausalLM, head_doc='''causal language modeling''') class snake_case ( _BaseAutoModelClass ): """simple docstring""" SCREAMING_SNAKE_CASE_ : Dict =FLAX_MODEL_FOR_MASKED_LM_MAPPING a__ : Tuple =auto_class_update(FlaxAutoModelForMaskedLM, head_doc='''masked language modeling''') class snake_case ( _BaseAutoModelClass ): """simple docstring""" SCREAMING_SNAKE_CASE_ : Dict =FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING a__ : Any =auto_class_update( FlaxAutoModelForSeqaSeqLM, head_doc='''sequence-to-sequence language modeling''', checkpoint_for_example='''t5-base''' ) class snake_case ( _BaseAutoModelClass ): """simple docstring""" SCREAMING_SNAKE_CASE_ : List[Any] =FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING a__ : int =auto_class_update( FlaxAutoModelForSequenceClassification, head_doc='''sequence classification''' ) class snake_case ( _BaseAutoModelClass ): """simple docstring""" SCREAMING_SNAKE_CASE_ : Any =FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING a__ : Any =auto_class_update(FlaxAutoModelForQuestionAnswering, head_doc='''question answering''') class snake_case ( _BaseAutoModelClass ): """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[int] =FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING a__ : Optional[Any] =auto_class_update( FlaxAutoModelForTokenClassification, head_doc='''token classification''' ) class snake_case ( _BaseAutoModelClass ): """simple docstring""" SCREAMING_SNAKE_CASE_ : str =FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING a__ : Tuple =auto_class_update(FlaxAutoModelForMultipleChoice, head_doc='''multiple choice''') class snake_case ( _BaseAutoModelClass ): """simple docstring""" SCREAMING_SNAKE_CASE_ : int =FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING a__ : Optional[int] =auto_class_update( FlaxAutoModelForNextSentencePrediction, head_doc='''next sentence prediction''' ) class snake_case ( _BaseAutoModelClass ): """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[int] =FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING a__ : Optional[Any] =auto_class_update( FlaxAutoModelForImageClassification, head_doc='''image classification''' ) class snake_case ( _BaseAutoModelClass ): """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[int] =FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING a__ : Union[str, Any] =auto_class_update(FlaxAutoModelForVisionaSeq, head_doc='''vision-to-text modeling''') class snake_case ( _BaseAutoModelClass ): """simple docstring""" SCREAMING_SNAKE_CASE_ : Union[str, Any] =FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING a__ : Tuple =auto_class_update( FlaxAutoModelForSpeechSeqaSeq, head_doc='''sequence-to-sequence speech-to-text modeling''' )

"""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 __A = logging.get_logger(__name__) __A = { "microsoft/beit-base-patch16-224-pt22k": ( "https://huggingface.co/microsoft/beit-base-patch16-224-pt22k/resolve/main/config.json" ), # See all BEiT models at https://huggingface.co/models?filter=beit } class snake_case ( __snake_case ): SCREAMING_SNAKE_CASE_ : Tuple = """beit""" def __init__( self : List[Any] , UpperCamelCase__ : List[str]=8_1_9_2 , UpperCamelCase__ : Dict=7_6_8 , UpperCamelCase__ : List[str]=1_2 , UpperCamelCase__ : Union[str, Any]=1_2 , UpperCamelCase__ : Dict=3_0_7_2 , UpperCamelCase__ : Optional[int]="gelu" , UpperCamelCase__ : Tuple=0.0 , UpperCamelCase__ : Tuple=0.0 , UpperCamelCase__ : Union[str, Any]=0.02 , UpperCamelCase__ : Optional[Any]=1e-12 , UpperCamelCase__ : str=2_2_4 , UpperCamelCase__ : str=1_6 , UpperCamelCase__ : Union[str, Any]=3 , UpperCamelCase__ : Optional[int]=False , UpperCamelCase__ : int=False , UpperCamelCase__ : Optional[Any]=False , UpperCamelCase__ : Optional[Any]=False , UpperCamelCase__ : Dict=0.1 , UpperCamelCase__ : List[Any]=0.1 , UpperCamelCase__ : Any=True , UpperCamelCase__ : Optional[Any]=[3, 5, 7, 1_1] , UpperCamelCase__ : Optional[Any]=[1, 2, 3, 6] , UpperCamelCase__ : Optional[Any]=True , UpperCamelCase__ : Tuple=0.4 , UpperCamelCase__ : Optional[Any]=2_5_6 , UpperCamelCase__ : Optional[int]=1 , UpperCamelCase__ : Optional[int]=False , UpperCamelCase__ : Optional[Any]=2_5_5 , **UpperCamelCase__ : Optional[int] , )-> int: '''simple docstring''' super().__init__(**UpperCamelCase__) __lowerCAmelCase: str = vocab_size __lowerCAmelCase: List[Any] = hidden_size __lowerCAmelCase: str = num_hidden_layers __lowerCAmelCase: Tuple = num_attention_heads __lowerCAmelCase: Union[str, Any] = intermediate_size __lowerCAmelCase: List[Any] = hidden_act __lowerCAmelCase: Optional[Any] = hidden_dropout_prob __lowerCAmelCase: List[Any] = attention_probs_dropout_prob __lowerCAmelCase: str = initializer_range __lowerCAmelCase: Optional[Any] = layer_norm_eps __lowerCAmelCase: Any = image_size __lowerCAmelCase: Any = patch_size __lowerCAmelCase: Union[str, Any] = num_channels __lowerCAmelCase: Tuple = use_mask_token __lowerCAmelCase: Optional[Any] = use_absolute_position_embeddings __lowerCAmelCase: List[Any] = use_relative_position_bias __lowerCAmelCase: Optional[Any] = use_shared_relative_position_bias __lowerCAmelCase: List[str] = layer_scale_init_value __lowerCAmelCase: str = drop_path_rate __lowerCAmelCase: str = use_mean_pooling # decode head attributes (semantic segmentation) __lowerCAmelCase: Optional[Any] = out_indices __lowerCAmelCase: Union[str, Any] = pool_scales # auxiliary head attributes (semantic segmentation) __lowerCAmelCase: List[str] = use_auxiliary_head __lowerCAmelCase: Union[str, Any] = auxiliary_loss_weight __lowerCAmelCase: Optional[int] = auxiliary_channels __lowerCAmelCase: Dict = auxiliary_num_convs __lowerCAmelCase: List[Any] = auxiliary_concat_input __lowerCAmelCase: str = semantic_loss_ignore_index class snake_case ( __snake_case ): SCREAMING_SNAKE_CASE_ : Optional[Any] = version.parse("""1.11""" ) @property def lowercase_ ( self : str)-> Mapping[str, Mapping[int, str]]: '''simple docstring''' return OrderedDict( [ ("pixel_values", {0: "batch", 1: "num_channels", 2: "height", 3: "width"}), ]) @property def lowercase_ ( self : Any)-> float: '''simple docstring''' return 1e-4

'''simple docstring''' lowerCamelCase_ = [ 'Audio', 'Array2D', 'Array3D', 'Array4D', 'Array5D', 'ClassLabel', 'Features', 'Sequence', 'Value', 'Image', 'Translation', 'TranslationVariableLanguages', ] from .audio import Audio from .features import ArrayaD, ArrayaD, ArrayaD, ArrayaD, ClassLabel, Features, Sequence, Value from .image import Image from .translation import Translation, TranslationVariableLanguages

'''simple docstring''' import random def SCREAMING_SNAKE_CASE_ ( __A : int , __A : float , __A : bool = False ) -> dict: _SCREAMING_SNAKE_CASE = {i: [] for i in range(__A )} # if probability is greater or equal than 1, then generate a complete graph if probability >= 1: return complete_graph(__A ) # if probability is lower or equal than 0, then return a graph without edges if probability <= 0: return graph # for each couple of nodes, add an edge from u to v # if the number randomly generated is greater than probability probability for i in range(__A ): for j in range(i + 1 , __A ): if random.random() < probability: graph[i].append(__A ) if not directed: # if the graph is undirected, add an edge in from j to i, either graph[j].append(__A ) return graph def SCREAMING_SNAKE_CASE_ ( __A : int ) -> dict: return { i: [j for j in range(__A ) if i != j] for i in range(__A ) } if __name__ == "__main__": import doctest doctest.testmod()

import logging from dataclasses import dataclass, field from typing import Optional from seqaseq_trainer import arg_to_scheduler from transformers import TrainingArguments __UpperCAmelCase = logging.getLogger(__name__) @dataclass class lowerCAmelCase_ ( a__ ): UpperCAmelCase__ : Optional[float] = field( default=0.0 , metadata={"help": "The label smoothing epsilon to apply (if not zero)."} ) UpperCAmelCase__ : bool = field(default=a__ , metadata={"help": "Whether to SortishSamler or not."} ) UpperCAmelCase__ : bool = field( default=a__ , metadata={"help": "Whether to use generate to calculate generative metrics (ROUGE, BLEU)."} ) UpperCAmelCase__ : bool = field(default=a__ , metadata={"help": "whether to use adafactor"} ) UpperCAmelCase__ : Optional[float] = field( default=a__ , metadata={"help": "Encoder layer dropout probability. Goes into model.config."} ) UpperCAmelCase__ : Optional[float] = field( default=a__ , metadata={"help": "Decoder layer dropout probability. Goes into model.config."} ) UpperCAmelCase__ : Optional[float] = field(default=a__ , metadata={"help": "Dropout probability. Goes into model.config."} ) UpperCAmelCase__ : Optional[float] = field( default=a__ , metadata={"help": "Attention dropout probability. Goes into model.config."} ) UpperCAmelCase__ : Optional[str] = field( default="linear" , metadata={"help": f'Which lr scheduler to use. Selected in {sorted(arg_to_scheduler.keys() )}'} , )

import argparse import json import os import numpy as np import PIL import requests import tensorflow.keras.applications.efficientnet as efficientnet import torch from huggingface_hub import hf_hub_download from PIL import Image from tensorflow.keras.preprocessing import image from transformers import ( EfficientNetConfig, EfficientNetForImageClassification, EfficientNetImageProcessor, ) from transformers.utils import logging logging.set_verbosity_info() __UpperCAmelCase = logging.get_logger(__name__) __UpperCAmelCase = { '''b0''': efficientnet.EfficientNetBa, '''b1''': efficientnet.EfficientNetBa, '''b2''': efficientnet.EfficientNetBa, '''b3''': efficientnet.EfficientNetBa, '''b4''': efficientnet.EfficientNetBa, '''b5''': efficientnet.EfficientNetBa, '''b6''': efficientnet.EfficientNetBa, '''b7''': efficientnet.EfficientNetBa, } __UpperCAmelCase = { '''b0''': { '''hidden_dim''': 1_280, '''width_coef''': 1.0, '''depth_coef''': 1.0, '''image_size''': 224, '''dropout_rate''': 0.2, '''dw_padding''': [], }, '''b1''': { '''hidden_dim''': 1_280, '''width_coef''': 1.0, '''depth_coef''': 1.1, '''image_size''': 240, '''dropout_rate''': 0.2, '''dw_padding''': [16], }, '''b2''': { '''hidden_dim''': 1_408, '''width_coef''': 1.1, '''depth_coef''': 1.2, '''image_size''': 260, '''dropout_rate''': 0.3, '''dw_padding''': [5, 8, 16], }, '''b3''': { '''hidden_dim''': 1_536, '''width_coef''': 1.2, '''depth_coef''': 1.4, '''image_size''': 300, '''dropout_rate''': 0.3, '''dw_padding''': [5, 18], }, '''b4''': { '''hidden_dim''': 1_792, '''width_coef''': 1.4, '''depth_coef''': 1.8, '''image_size''': 380, '''dropout_rate''': 0.4, '''dw_padding''': [6], }, '''b5''': { '''hidden_dim''': 2_048, '''width_coef''': 1.6, '''depth_coef''': 2.2, '''image_size''': 456, '''dropout_rate''': 0.4, '''dw_padding''': [13, 27], }, '''b6''': { '''hidden_dim''': 2_304, '''width_coef''': 1.8, '''depth_coef''': 2.6, '''image_size''': 528, '''dropout_rate''': 0.5, '''dw_padding''': [31], }, '''b7''': { '''hidden_dim''': 2_560, '''width_coef''': 2.0, '''depth_coef''': 3.1, '''image_size''': 600, '''dropout_rate''': 0.5, '''dw_padding''': [18], }, } def UpperCamelCase ( snake_case__ : int ) -> Optional[int]: UpperCamelCase : str = EfficientNetConfig() UpperCamelCase : Union[str, Any] = CONFIG_MAP[model_name]['hidden_dim'] UpperCamelCase : Union[str, Any] = CONFIG_MAP[model_name]['width_coef'] UpperCamelCase : str = CONFIG_MAP[model_name]['depth_coef'] UpperCamelCase : List[str] = CONFIG_MAP[model_name]['image_size'] UpperCamelCase : List[str] = CONFIG_MAP[model_name]['dropout_rate'] UpperCamelCase : str = CONFIG_MAP[model_name]['dw_padding'] UpperCamelCase : str = 'huggingface/label-files' UpperCamelCase : Optional[Any] = 'imagenet-1k-id2label.json' UpperCamelCase : Optional[Any] = 1000 UpperCamelCase : Dict = json.load(open(hf_hub_download(snake_case__ , snake_case__ , repo_type='dataset' ) , 'r' ) ) UpperCamelCase : Tuple = {int(snake_case__ ): v for k, v in idalabel.items()} UpperCamelCase : Optional[int] = idalabel UpperCamelCase : Tuple = {v: k for k, v in idalabel.items()} return config def UpperCamelCase ( ) -> Tuple: UpperCamelCase : Optional[Any] = 'http://images.cocodataset.org/val2017/000000039769.jpg' UpperCamelCase : Union[str, Any] = Image.open(requests.get(snake_case__ , stream=snake_case__ ).raw ) return im def UpperCamelCase ( snake_case__ : List[str] ) -> List[Any]: UpperCamelCase : int = CONFIG_MAP[model_name]['image_size'] UpperCamelCase : List[str] = EfficientNetImageProcessor( size={'height': size, 'width': size} , image_mean=[0.485, 0.456, 0.406] , image_std=[0.47853944, 0.4732864, 0.47434163] , do_center_crop=snake_case__ , ) return preprocessor def UpperCamelCase ( snake_case__ : Optional[int] ) -> Dict: UpperCamelCase : int = [v.split('_' )[0].split('block' )[1] for v in original_param_names if v.startswith('block' )] UpperCamelCase : str = sorted(set(snake_case__ ) ) UpperCamelCase : int = len(snake_case__ ) UpperCamelCase : str = {b: str(snake_case__ ) for b, i in zip(snake_case__ , range(snake_case__ ) )} UpperCamelCase : Optional[int] = [] rename_keys.append(('stem_conv/kernel:0', 'embeddings.convolution.weight') ) rename_keys.append(('stem_bn/gamma:0', 'embeddings.batchnorm.weight') ) rename_keys.append(('stem_bn/beta:0', 'embeddings.batchnorm.bias') ) rename_keys.append(('stem_bn/moving_mean:0', 'embeddings.batchnorm.running_mean') ) rename_keys.append(('stem_bn/moving_variance:0', 'embeddings.batchnorm.running_var') ) for b in block_names: UpperCamelCase : Union[str, Any] = block_name_mapping[b] rename_keys.append((F"""block{b}_expand_conv/kernel:0""", F"""encoder.blocks.{hf_b}.expansion.expand_conv.weight""") ) rename_keys.append((F"""block{b}_expand_bn/gamma:0""", F"""encoder.blocks.{hf_b}.expansion.expand_bn.weight""") ) rename_keys.append((F"""block{b}_expand_bn/beta:0""", F"""encoder.blocks.{hf_b}.expansion.expand_bn.bias""") ) rename_keys.append( (F"""block{b}_expand_bn/moving_mean:0""", F"""encoder.blocks.{hf_b}.expansion.expand_bn.running_mean""") ) rename_keys.append( (F"""block{b}_expand_bn/moving_variance:0""", F"""encoder.blocks.{hf_b}.expansion.expand_bn.running_var""") ) rename_keys.append( (F"""block{b}_dwconv/depthwise_kernel:0""", F"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_conv.weight""") ) rename_keys.append((F"""block{b}_bn/gamma:0""", F"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.weight""") ) rename_keys.append((F"""block{b}_bn/beta:0""", F"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.bias""") ) rename_keys.append( (F"""block{b}_bn/moving_mean:0""", F"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_mean""") ) rename_keys.append( (F"""block{b}_bn/moving_variance:0""", F"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_var""") ) rename_keys.append((F"""block{b}_se_reduce/kernel:0""", F"""encoder.blocks.{hf_b}.squeeze_excite.reduce.weight""") ) rename_keys.append((F"""block{b}_se_reduce/bias:0""", F"""encoder.blocks.{hf_b}.squeeze_excite.reduce.bias""") ) rename_keys.append((F"""block{b}_se_expand/kernel:0""", F"""encoder.blocks.{hf_b}.squeeze_excite.expand.weight""") ) rename_keys.append((F"""block{b}_se_expand/bias:0""", F"""encoder.blocks.{hf_b}.squeeze_excite.expand.bias""") ) rename_keys.append( (F"""block{b}_project_conv/kernel:0""", F"""encoder.blocks.{hf_b}.projection.project_conv.weight""") ) rename_keys.append((F"""block{b}_project_bn/gamma:0""", F"""encoder.blocks.{hf_b}.projection.project_bn.weight""") ) rename_keys.append((F"""block{b}_project_bn/beta:0""", F"""encoder.blocks.{hf_b}.projection.project_bn.bias""") ) rename_keys.append( (F"""block{b}_project_bn/moving_mean:0""", F"""encoder.blocks.{hf_b}.projection.project_bn.running_mean""") ) rename_keys.append( (F"""block{b}_project_bn/moving_variance:0""", F"""encoder.blocks.{hf_b}.projection.project_bn.running_var""") ) rename_keys.append(('top_conv/kernel:0', 'encoder.top_conv.weight') ) rename_keys.append(('top_bn/gamma:0', 'encoder.top_bn.weight') ) rename_keys.append(('top_bn/beta:0', 'encoder.top_bn.bias') ) rename_keys.append(('top_bn/moving_mean:0', 'encoder.top_bn.running_mean') ) rename_keys.append(('top_bn/moving_variance:0', 'encoder.top_bn.running_var') ) UpperCamelCase : List[str] = {} for item in rename_keys: if item[0] in original_param_names: UpperCamelCase : Dict = 'efficientnet.' + item[1] UpperCamelCase : Dict = 'classifier.weight' UpperCamelCase : Dict = 'classifier.bias' return key_mapping def UpperCamelCase ( snake_case__ : Optional[Any] , snake_case__ : List[Any] , snake_case__ : int ) -> Dict: for key, value in tf_params.items(): if "normalization" in key: continue UpperCamelCase : Any = key_mapping[key] if "_conv" in key and "kernel" in key: UpperCamelCase : str = torch.from_numpy(snake_case__ ).permute(3 , 2 , 0 , 1 ) elif "depthwise_kernel" in key: UpperCamelCase : Any = torch.from_numpy(snake_case__ ).permute(2 , 3 , 0 , 1 ) elif "kernel" in key: UpperCamelCase : str = torch.from_numpy(np.transpose(snake_case__ ) ) else: UpperCamelCase : str = torch.from_numpy(snake_case__ ) # Replace HF parameters with original TF model parameters assert hf_params[hf_key].shape == new_hf_value.shape hf_params[hf_key].copy_(snake_case__ ) @torch.no_grad() def UpperCamelCase ( snake_case__ : Optional[Any] , snake_case__ : Dict , snake_case__ : int , snake_case__ : Optional[int] ) -> Any: UpperCamelCase : Union[str, Any] = model_classes[model_name]( include_top=snake_case__ , weights='imagenet' , input_tensor=snake_case__ , input_shape=snake_case__ , pooling=snake_case__ , classes=1000 , classifier_activation='softmax' , ) UpperCamelCase : Optional[int] = original_model.trainable_variables UpperCamelCase : Optional[int] = original_model.non_trainable_variables UpperCamelCase : Tuple = {param.name: param.numpy() for param in tf_params} for param in tf_non_train_params: UpperCamelCase : List[Any] = param.numpy() UpperCamelCase : List[str] = list(tf_params.keys() ) # Load HuggingFace model UpperCamelCase : str = get_efficientnet_config(snake_case__ ) UpperCamelCase : Any = EfficientNetForImageClassification(snake_case__ ).eval() UpperCamelCase : Tuple = hf_model.state_dict() # Create src-to-dst parameter name mapping dictionary print('Converting parameters...' ) UpperCamelCase : List[Any] = rename_keys(snake_case__ ) replace_params(snake_case__ , snake_case__ , snake_case__ ) # Initialize preprocessor and preprocess input image UpperCamelCase : List[Any] = convert_image_processor(snake_case__ ) UpperCamelCase : Dict = preprocessor(images=prepare_img() , return_tensors='pt' ) # HF model inference hf_model.eval() with torch.no_grad(): UpperCamelCase : Optional[int] = hf_model(**snake_case__ ) UpperCamelCase : Dict = outputs.logits.detach().numpy() # Original model inference UpperCamelCase : Optional[int] = False UpperCamelCase : int = CONFIG_MAP[model_name]['image_size'] UpperCamelCase : List[Any] = prepare_img().resize((image_size, image_size) , resample=PIL.Image.NEAREST ) UpperCamelCase : List[Any] = image.img_to_array(snake_case__ ) UpperCamelCase : str = np.expand_dims(snake_case__ , axis=0 ) UpperCamelCase : Any = original_model.predict(snake_case__ ) # Check whether original and HF model outputs match -> np.allclose assert np.allclose(snake_case__ , snake_case__ , atol=1E-3 ), "The predicted logits are not the same." print('Model outputs match!' ) if save_model: # Create folder to save model if not os.path.isdir(snake_case__ ): os.mkdir(snake_case__ ) # Save converted model and image processor hf_model.save_pretrained(snake_case__ ) preprocessor.save_pretrained(snake_case__ ) if push_to_hub: # Push model and image processor to hub print(F"""Pushing converted {model_name} to the hub...""" ) UpperCamelCase : List[str] = F"""efficientnet-{model_name}""" preprocessor.push_to_hub(snake_case__ ) hf_model.push_to_hub(snake_case__ ) if __name__ == "__main__": __UpperCAmelCase = argparse.ArgumentParser() # Required parameters parser.add_argument( '''--model_name''', default='''b0''', type=str, help='''Version name of the EfficientNet model you want to convert, select from [b0, b1, b2, b3, b4, b5, b6, b7].''', ) parser.add_argument( '''--pytorch_dump_folder_path''', default='''hf_model''', type=str, help='''Path to the output PyTorch model directory.''', ) parser.add_argument('''--save_model''', action='''store_true''', help='''Save model to local''') parser.add_argument('''--push_to_hub''', action='''store_true''', help='''Push model and image processor to the hub''') __UpperCAmelCase = parser.parse_args() convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)

import json import os import tempfile import unittest import unittest.mock as mock from pathlib import Path from requests.exceptions import HTTPError from transformers.utils import ( CONFIG_NAME, FLAX_WEIGHTS_NAME, TF2_WEIGHTS_NAME, TRANSFORMERS_CACHE, WEIGHTS_NAME, cached_file, get_file_from_repo, has_file, ) _UpperCAmelCase = 'hf-internal-testing/tiny-random-bert' _UpperCAmelCase = os.path.join(TRANSFORMERS_CACHE, 'models--hf-internal-testing--tiny-random-bert') _UpperCAmelCase = '9b8c223d42b2188cb49d29af482996f9d0f3e5a6' class snake_case_ ( unittest.TestCase ): def UpperCAmelCase__ ( self : Union[str, Any] )->List[Any]: '''simple docstring''' __lowerCAmelCase : Union[str, Any] = cached_file(_snake_case , _snake_case ) # Should have downloaded the file in here self.assertTrue(os.path.isdir(_snake_case ) ) # Cache should contain at least those three subfolders: for subfolder in ["blobs", "refs", "snapshots"]: self.assertTrue(os.path.isdir(os.path.join(_snake_case , _snake_case ) ) ) with open(os.path.join(_snake_case , """refs""" , """main""" ) ) as f: __lowerCAmelCase : List[Any] = f.read() self.assertEqual(_snake_case , os.path.join(_snake_case , """snapshots""" , _snake_case , _snake_case ) ) self.assertTrue(os.path.isfile(_snake_case ) ) # File is cached at the same place the second time. __lowerCAmelCase : Dict = cached_file(_snake_case , _snake_case ) self.assertEqual(_snake_case , _snake_case ) # Using a specific revision to test the full commit hash. __lowerCAmelCase : Any = cached_file(_snake_case , _snake_case , revision="""9b8c223""" ) self.assertEqual(_snake_case , os.path.join(_snake_case , """snapshots""" , _snake_case , _snake_case ) ) def UpperCAmelCase__ ( self : Tuple )->str: '''simple docstring''' with self.assertRaisesRegex(_snake_case , """is not a valid model identifier""" ): __lowerCAmelCase : Any = cached_file("""tiny-random-bert""" , _snake_case ) with self.assertRaisesRegex(_snake_case , """is not a valid git identifier""" ): __lowerCAmelCase : Tuple = cached_file(_snake_case , _snake_case , revision="""aaaa""" ) with self.assertRaisesRegex(_snake_case , """does not appear to have a file named""" ): __lowerCAmelCase : Any = cached_file(_snake_case , """conf""" ) def UpperCAmelCase__ ( self : Tuple )->Optional[int]: '''simple docstring''' with self.assertRaisesRegex(_snake_case , """does not appear to have a file named""" ): __lowerCAmelCase : Optional[Any] = cached_file(_snake_case , """conf""" ) with open(os.path.join(_snake_case , """refs""" , """main""" ) ) as f: __lowerCAmelCase : Union[str, Any] = f.read() self.assertTrue(os.path.isfile(os.path.join(_snake_case , """.no_exist""" , _snake_case , """conf""" ) ) ) __lowerCAmelCase : Tuple = cached_file(_snake_case , """conf""" , _raise_exceptions_for_missing_entries=_snake_case ) self.assertIsNone(_snake_case ) __lowerCAmelCase : List[Any] = cached_file(_snake_case , """conf""" , local_files_only=_snake_case , _raise_exceptions_for_missing_entries=_snake_case ) self.assertIsNone(_snake_case ) __lowerCAmelCase : Dict = mock.Mock() __lowerCAmelCase : List[Any] = 500 __lowerCAmelCase : int = {} __lowerCAmelCase : int = HTTPError __lowerCAmelCase : Dict = {} # Under the mock environment we get a 500 error when trying to reach the tokenizer. with mock.patch("""requests.Session.request""" , return_value=_snake_case ) as mock_head: __lowerCAmelCase : Optional[int] = cached_file(_snake_case , """conf""" , _raise_exceptions_for_connection_errors=_snake_case ) self.assertIsNone(_snake_case ) # This check we did call the fake head request mock_head.assert_called() def UpperCAmelCase__ ( self : List[str] )->int: '''simple docstring''' self.assertTrue(has_file("""hf-internal-testing/tiny-bert-pt-only""" , _snake_case ) ) self.assertFalse(has_file("""hf-internal-testing/tiny-bert-pt-only""" , _snake_case ) ) self.assertFalse(has_file("""hf-internal-testing/tiny-bert-pt-only""" , _snake_case ) ) def UpperCAmelCase__ ( self : Dict )->Optional[int]: '''simple docstring''' self.assertIsNone(get_file_from_repo("""bert-base-cased""" , """ahah.txt""" ) ) # The function raises if the repository does not exist. with self.assertRaisesRegex(_snake_case , """is not a valid model identifier""" ): get_file_from_repo("""bert-base-case""" , _snake_case ) # The function raises if the revision does not exist. with self.assertRaisesRegex(_snake_case , """is not a valid git identifier""" ): get_file_from_repo("""bert-base-cased""" , _snake_case , revision="""ahaha""" ) __lowerCAmelCase : Dict = get_file_from_repo("""bert-base-cased""" , _snake_case ) # The name is the cached name which is not very easy to test, so instead we load the content. __lowerCAmelCase : Optional[int] = json.loads(open(_snake_case , """r""" ).read() ) self.assertEqual(config["""hidden_size"""] , 768 ) def UpperCAmelCase__ ( self : Optional[int] )->Any: '''simple docstring''' with tempfile.TemporaryDirectory() as tmp_dir: __lowerCAmelCase : List[Any] = Path(_snake_case ) / """a.txt""" filename.touch() self.assertEqual(get_file_from_repo(_snake_case , """a.txt""" ) , str(_snake_case ) ) self.assertIsNone(get_file_from_repo(_snake_case , """b.txt""" ) )

from ...configuration_utils import PretrainedConfig from ...utils import logging _UpperCAmelCase = logging.get_logger(__name__) _UpperCAmelCase = { 'microsoft/biogpt': 'https://huggingface.co/microsoft/biogpt/resolve/main/config.json', # See all BioGPT models at https://huggingface.co/models?filter=biogpt } class snake_case_ ( __lowercase ): A_ = 'biogpt' def __init__( self : int , _snake_case : Any=42384 , _snake_case : Any=1024 , _snake_case : List[Any]=24 , _snake_case : Any=16 , _snake_case : List[str]=4096 , _snake_case : Dict="gelu" , _snake_case : Tuple=0.1 , _snake_case : str=0.1 , _snake_case : Tuple=1024 , _snake_case : Tuple=0.02 , _snake_case : Tuple=1E-12 , _snake_case : Optional[int]=True , _snake_case : Optional[int]=True , _snake_case : Any=0.0 , _snake_case : Tuple=0.0 , _snake_case : str=1 , _snake_case : Dict=0 , _snake_case : str=2 , **_snake_case : Union[str, Any] , )->Dict: '''simple docstring''' __lowerCAmelCase : List[Any] = vocab_size __lowerCAmelCase : Dict = max_position_embeddings __lowerCAmelCase : str = hidden_size __lowerCAmelCase : Dict = num_hidden_layers __lowerCAmelCase : List[Any] = num_attention_heads __lowerCAmelCase : Optional[Any] = intermediate_size __lowerCAmelCase : int = hidden_act __lowerCAmelCase : Any = hidden_dropout_prob __lowerCAmelCase : Any = attention_probs_dropout_prob __lowerCAmelCase : Any = initializer_range __lowerCAmelCase : int = layer_norm_eps __lowerCAmelCase : Optional[int] = scale_embedding __lowerCAmelCase : List[Any] = use_cache __lowerCAmelCase : str = layerdrop __lowerCAmelCase : Dict = activation_dropout super().__init__(pad_token_id=_snake_case , bos_token_id=_snake_case , eos_token_id=_snake_case , **_snake_case )

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 logging snake_case : Optional[int] = logging.get_logger(__name__) snake_case : Any = {'''vocab_file''': '''spiece.model'''} snake_case : List[Any] = { '''vocab_file''': { '''albert-base-v1''': '''https://huggingface.co/albert-base-v1/resolve/main/spiece.model''', '''albert-large-v1''': '''https://huggingface.co/albert-large-v1/resolve/main/spiece.model''', '''albert-xlarge-v1''': '''https://huggingface.co/albert-xlarge-v1/resolve/main/spiece.model''', '''albert-xxlarge-v1''': '''https://huggingface.co/albert-xxlarge-v1/resolve/main/spiece.model''', '''albert-base-v2''': '''https://huggingface.co/albert-base-v2/resolve/main/spiece.model''', '''albert-large-v2''': '''https://huggingface.co/albert-large-v2/resolve/main/spiece.model''', '''albert-xlarge-v2''': '''https://huggingface.co/albert-xlarge-v2/resolve/main/spiece.model''', '''albert-xxlarge-v2''': '''https://huggingface.co/albert-xxlarge-v2/resolve/main/spiece.model''', } } snake_case : int = { '''albert-base-v1''': 5_12, '''albert-large-v1''': 5_12, '''albert-xlarge-v1''': 5_12, '''albert-xxlarge-v1''': 5_12, '''albert-base-v2''': 5_12, '''albert-large-v2''': 5_12, '''albert-xlarge-v2''': 5_12, '''albert-xxlarge-v2''': 5_12, } snake_case : List[Any] = '''▁''' class _snake_case ( _snake_case ): SCREAMING_SNAKE_CASE__ = VOCAB_FILES_NAMES SCREAMING_SNAKE_CASE__ = PRETRAINED_VOCAB_FILES_MAP SCREAMING_SNAKE_CASE__ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES def __init__( self , _lowerCamelCase , _lowerCamelCase=True , _lowerCamelCase=True , _lowerCamelCase=False , _lowerCamelCase="[CLS]" , _lowerCamelCase="[SEP]" , _lowerCamelCase="<unk>" , _lowerCamelCase="[SEP]" , _lowerCamelCase="<pad>" , _lowerCamelCase="[CLS]" , _lowerCamelCase="[MASK]" , _lowerCamelCase = None , **_lowerCamelCase , ): # Mask token behave like a normal word, i.e. include the space before it and # is included in the raw text, there should be a match in a non-normalized sentence. a :str = ( AddedToken(_lowerCamelCase , lstrip=_lowerCamelCase , rstrip=_lowerCamelCase , normalized=_lowerCamelCase ) if isinstance(_lowerCamelCase , _lowerCamelCase ) else mask_token ) a :str = {} if sp_model_kwargs is None else sp_model_kwargs super().__init__( do_lower_case=_lowerCamelCase , remove_space=_lowerCamelCase , keep_accents=_lowerCamelCase , bos_token=_lowerCamelCase , eos_token=_lowerCamelCase , unk_token=_lowerCamelCase , sep_token=_lowerCamelCase , pad_token=_lowerCamelCase , cls_token=_lowerCamelCase , mask_token=_lowerCamelCase , sp_model_kwargs=self.sp_model_kwargs , **_lowerCamelCase , ) a :List[Any] = do_lower_case a :int = remove_space a :List[Any] = keep_accents a :Optional[int] = vocab_file a :Tuple = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(_lowerCamelCase ) @property def SCREAMING_SNAKE_CASE__ ( self ): return len(self.sp_model ) def SCREAMING_SNAKE_CASE__ ( self ): a :Optional[Any] = {self.convert_ids_to_tokens(_lowerCamelCase ): i for i in range(self.vocab_size )} vocab.update(self.added_tokens_encoder ) return vocab def __getstate__( self ): a :Optional[int] = self.__dict__.copy() a :int = None return state def __setstate__( self , _lowerCamelCase ): a :Union[str, Any] = d # for backward compatibility if not hasattr(self , '''sp_model_kwargs''' ): a :Any = {} a :List[Any] = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(self.vocab_file ) def SCREAMING_SNAKE_CASE__ ( self , _lowerCamelCase ): if self.remove_space: a :int = ''' '''.join(inputs.strip().split() ) else: a :Tuple = inputs a :Tuple = outputs.replace('''``''' , '''"''' ).replace('''\'\'''' , '''"''' ) if not self.keep_accents: a :List[str] = unicodedata.normalize('''NFKD''' , _lowerCamelCase ) a :List[str] = ''''''.join([c for c in outputs if not unicodedata.combining(_lowerCamelCase )] ) if self.do_lower_case: a :Tuple = outputs.lower() return outputs def SCREAMING_SNAKE_CASE__ ( self , _lowerCamelCase ): a :Optional[Any] = self.preprocess_text(_lowerCamelCase ) a :int = self.sp_model.encode(_lowerCamelCase , out_type=_lowerCamelCase ) a :Tuple = [] for piece in pieces: if len(_lowerCamelCase ) > 1 and piece[-1] == str(''',''' ) and piece[-2].isdigit(): a :int = self.sp_model.EncodeAsPieces(piece[:-1].replace(_lowerCamelCase , '''''' ) ) if piece[0] != SPIECE_UNDERLINE and cur_pieces[0][0] == SPIECE_UNDERLINE: if len(cur_pieces[0] ) == 1: a :List[str] = cur_pieces[1:] else: a :Optional[Any] = cur_pieces[0][1:] cur_pieces.append(piece[-1] ) new_pieces.extend(_lowerCamelCase ) else: new_pieces.append(_lowerCamelCase ) return new_pieces def SCREAMING_SNAKE_CASE__ ( self , _lowerCamelCase ): return self.sp_model.PieceToId(_lowerCamelCase ) def SCREAMING_SNAKE_CASE__ ( self , _lowerCamelCase ): return self.sp_model.IdToPiece(_lowerCamelCase ) def SCREAMING_SNAKE_CASE__ ( self , _lowerCamelCase ): a :Dict = [] a :List[Any] = '''''' a :str = False for token in tokens: # make sure that special tokens are not decoded using sentencepiece model if token in self.all_special_tokens: if not prev_is_special: out_string += " " out_string += self.sp_model.decode(_lowerCamelCase ) + token a :Optional[int] = True a :str = [] else: current_sub_tokens.append(_lowerCamelCase ) a :Optional[int] = False out_string += self.sp_model.decode(_lowerCamelCase ) return out_string.strip() def SCREAMING_SNAKE_CASE__ ( self , _lowerCamelCase , _lowerCamelCase = None ): a :str = [self.sep_token_id] a :str = [self.cls_token_id] if token_ids_a is None: return cls + token_ids_a + sep return cls + token_ids_a + sep + token_ids_a + sep def SCREAMING_SNAKE_CASE__ ( self , _lowerCamelCase , _lowerCamelCase = None , _lowerCamelCase = False ): if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=_lowerCamelCase , token_ids_a=_lowerCamelCase , already_has_special_tokens=_lowerCamelCase ) if token_ids_a is not None: return [1] + ([0] * len(_lowerCamelCase )) + [1] + ([0] * len(_lowerCamelCase )) + [1] return [1] + ([0] * len(_lowerCamelCase )) + [1] def SCREAMING_SNAKE_CASE__ ( self , _lowerCamelCase , _lowerCamelCase = None ): a :Union[str, Any] = [self.sep_token_id] a :Optional[int] = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def SCREAMING_SNAKE_CASE__ ( self , _lowerCamelCase , _lowerCamelCase = None ): if not os.path.isdir(_lowerCamelCase ): logger.error(F'''Vocabulary path ({save_directory}) should be a directory''' ) return a :Dict = os.path.join( _lowerCamelCase , (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file'''] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(_lowerCamelCase ) and os.path.isfile(self.vocab_file ): copyfile(self.vocab_file , _lowerCamelCase ) elif not os.path.isfile(self.vocab_file ): with open(_lowerCamelCase , '''wb''' ) as fi: a :Dict = self.sp_model.serialized_model_proto() fi.write(_lowerCamelCase ) return (out_vocab_file,)

import json from typing import TYPE_CHECKING, List, Optional, Tuple from tokenizers import pre_tokenizers, processors from ...tokenization_utils_base import AddedToken, BatchEncoding from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_blenderbot import BlenderbotTokenizer if TYPE_CHECKING: from transformers.pipelines.conversational import Conversation lowerCamelCase : Union[str, Any] =logging.get_logger(__name__) lowerCamelCase : str ={ '''vocab_file''': '''vocab.json''', '''merges_file''': '''merges.txt''', '''tokenizer_config_file''': '''tokenizer_config.json''', } lowerCamelCase : str ={ '''vocab_file''': {'''facebook/blenderbot-3B''': '''https://huggingface.co/facebook/blenderbot-3B/resolve/main/vocab.json'''}, '''merges_file''': {'''facebook/blenderbot-3B''': '''https://huggingface.co/facebook/blenderbot-3B/resolve/main/merges.txt'''}, '''tokenizer_config_file''': { '''facebook/blenderbot-3B''': '''https://huggingface.co/facebook/blenderbot-3B/resolve/main/tokenizer_config.json''' }, } lowerCamelCase : str ={'''facebook/blenderbot-3B''': 128} class __a ( A__ ): _lowerCAmelCase : Union[str, Any] = VOCAB_FILES_NAMES _lowerCAmelCase : Dict = PRETRAINED_VOCAB_FILES_MAP _lowerCAmelCase : List[Any] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _lowerCAmelCase : int = ['''input_ids''', '''attention_mask'''] _lowerCAmelCase : Tuple = BlenderbotTokenizer def __init__( self : List[Any] , SCREAMING_SNAKE_CASE : Optional[int]=None , SCREAMING_SNAKE_CASE : Dict=None , SCREAMING_SNAKE_CASE : Union[str, Any]=None , SCREAMING_SNAKE_CASE : Tuple="replace" , SCREAMING_SNAKE_CASE : Union[str, Any]="<s>" , SCREAMING_SNAKE_CASE : str="</s>" , SCREAMING_SNAKE_CASE : str="</s>" , SCREAMING_SNAKE_CASE : Tuple="<s>" , SCREAMING_SNAKE_CASE : Union[str, Any]="<unk>" , SCREAMING_SNAKE_CASE : str="<pad>" , SCREAMING_SNAKE_CASE : Union[str, Any]="<mask>" , SCREAMING_SNAKE_CASE : Any=False , SCREAMING_SNAKE_CASE : List[Any]=True , **SCREAMING_SNAKE_CASE : int , ): '''simple docstring''' super().__init__( SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , tokenizer_file=SCREAMING_SNAKE_CASE , errors=SCREAMING_SNAKE_CASE , bos_token=SCREAMING_SNAKE_CASE , eos_token=SCREAMING_SNAKE_CASE , sep_token=SCREAMING_SNAKE_CASE , cls_token=SCREAMING_SNAKE_CASE , unk_token=SCREAMING_SNAKE_CASE , pad_token=SCREAMING_SNAKE_CASE , mask_token=SCREAMING_SNAKE_CASE , add_prefix_space=SCREAMING_SNAKE_CASE , trim_offsets=SCREAMING_SNAKE_CASE , **SCREAMING_SNAKE_CASE , ) UpperCamelCase__ : List[Any] = json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__() ) if pre_tok_state.get("add_prefix_space" , SCREAMING_SNAKE_CASE ) != add_prefix_space: UpperCamelCase__ : str = getattr(SCREAMING_SNAKE_CASE , pre_tok_state.pop("type" ) ) UpperCamelCase__ : Union[str, Any] = add_prefix_space UpperCamelCase__ : Union[str, Any] = pre_tok_class(**SCREAMING_SNAKE_CASE ) UpperCamelCase__ : Tuple = add_prefix_space UpperCamelCase__ : Optional[int] = "post_processor" UpperCamelCase__ : Union[str, Any] = getattr(self.backend_tokenizer , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE ) if tokenizer_component_instance: UpperCamelCase__ : Tuple = json.loads(tokenizer_component_instance.__getstate__() ) # The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class` if "sep" in state: UpperCamelCase__ : Tuple = tuple(state["sep"] ) if "cls" in state: UpperCamelCase__ : Optional[int] = tuple(state["cls"] ) UpperCamelCase__ : List[Any] = False if state.get("add_prefix_space" , SCREAMING_SNAKE_CASE ) != add_prefix_space: UpperCamelCase__ : str = add_prefix_space UpperCamelCase__ : Optional[Any] = True if state.get("trim_offsets" , SCREAMING_SNAKE_CASE ) != trim_offsets: UpperCamelCase__ : Optional[Any] = trim_offsets UpperCamelCase__ : Tuple = True if changes_to_apply: UpperCamelCase__ : Optional[int] = getattr(SCREAMING_SNAKE_CASE , state.pop("type" ) ) UpperCamelCase__ : Dict = component_class(**SCREAMING_SNAKE_CASE ) setattr(self.backend_tokenizer , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE ) @property # Copied from transformers.models.roberta.tokenization_roberta_fast.RobertaTokenizerFast.mask_token with Roberta->Blenderbot, RoBERTa->Blenderbot def __lowercase ( self : Union[str, Any] ): '''simple docstring''' if self._mask_token is None: if self.verbose: logger.error("Using mask_token, but it is not set yet." ) return None return str(self._mask_token ) @mask_token.setter def __lowercase ( self : Union[str, Any] , SCREAMING_SNAKE_CASE : Optional[int] ): '''simple docstring''' UpperCamelCase__ : Dict = AddedToken(SCREAMING_SNAKE_CASE , lstrip=SCREAMING_SNAKE_CASE , rstrip=SCREAMING_SNAKE_CASE ) if isinstance(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE ) else value UpperCamelCase__ : str = value def __lowercase ( self : Any , *SCREAMING_SNAKE_CASE : List[str] , **SCREAMING_SNAKE_CASE : Tuple ): '''simple docstring''' UpperCamelCase__ : List[Any] = kwargs.get("is_split_into_words" , SCREAMING_SNAKE_CASE ) 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(*SCREAMING_SNAKE_CASE , **SCREAMING_SNAKE_CASE ) def __lowercase ( self : Dict , *SCREAMING_SNAKE_CASE : int , **SCREAMING_SNAKE_CASE : Dict ): '''simple docstring''' UpperCamelCase__ : Dict = kwargs.get("is_split_into_words" , SCREAMING_SNAKE_CASE ) 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(*SCREAMING_SNAKE_CASE , **SCREAMING_SNAKE_CASE ) def __lowercase ( self : Union[str, Any] , SCREAMING_SNAKE_CASE : str , SCREAMING_SNAKE_CASE : Optional[str] = None ): '''simple docstring''' UpperCamelCase__ : Optional[Any] = self._tokenizer.model.save(SCREAMING_SNAKE_CASE , name=SCREAMING_SNAKE_CASE ) return tuple(SCREAMING_SNAKE_CASE ) def __lowercase ( self : Optional[int] , SCREAMING_SNAKE_CASE : List[int] , SCREAMING_SNAKE_CASE : Optional[List[int]] = None ): '''simple docstring''' UpperCamelCase__ : Optional[Any] = [self.sep_token_id] UpperCamelCase__ : int = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0] def __lowercase ( self : List[Any] , SCREAMING_SNAKE_CASE : List[int] , SCREAMING_SNAKE_CASE : Optional[List[int]] = None ): '''simple docstring''' return token_ids_a + [self.eos_token_id] def __lowercase ( self : Union[str, Any] , SCREAMING_SNAKE_CASE : "Conversation" ): '''simple docstring''' UpperCamelCase__ : Optional[Any] = [] for is_user, text in conversation.iter_texts(): if is_user: # We need to space prefix as it's being done within blenderbot inputs.append(" " + text ) else: # Generated responses should contain them already. inputs.append(SCREAMING_SNAKE_CASE ) UpperCamelCase__ : List[str] = " ".join(SCREAMING_SNAKE_CASE ) UpperCamelCase__ : Optional[Any] = self.encode(SCREAMING_SNAKE_CASE ) if len(SCREAMING_SNAKE_CASE ) > self.model_max_length: UpperCamelCase__ : Dict = input_ids[-self.model_max_length :] logger.warning(F'Trimmed input from conversation as it was longer than {self.model_max_length} tokens.' ) return input_ids

'''simple docstring''' import argparse import json import os import fairseq import torch from fairseq.data import Dictionary from transformers import ( WavaVecaConfig, WavaVecaCTCTokenizer, WavaVecaFeatureExtractor, WavaVecaForCTC, WavaVecaForPreTraining, WavaVecaProcessor, logging, ) from transformers.models.wavaveca.modeling_wavaveca import WavaVecaForSequenceClassification logging.set_verbosity_info() __lowercase : Dict = logging.get_logger(__name__) __lowercase : Optional[Any] = { 'post_extract_proj': 'feature_projection.projection', 'encoder.pos_conv.0': 'encoder.pos_conv_embed.conv', 'self_attn.k_proj': 'encoder.layers.*.attention.k_proj', 'self_attn.v_proj': 'encoder.layers.*.attention.v_proj', 'self_attn.q_proj': 'encoder.layers.*.attention.q_proj', 'self_attn.out_proj': 'encoder.layers.*.attention.out_proj', 'self_attn_layer_norm': 'encoder.layers.*.layer_norm', 'fc1': 'encoder.layers.*.feed_forward.intermediate_dense', 'fc2': 'encoder.layers.*.feed_forward.output_dense', 'final_layer_norm': 'encoder.layers.*.final_layer_norm', 'encoder.layer_norm': 'encoder.layer_norm', 'adapter_layer': 'encoder.layers.*.adapter_layer', 'w2v_model.layer_norm': 'feature_projection.layer_norm', 'quantizer.weight_proj': 'quantizer.weight_proj', 'quantizer.vars': 'quantizer.codevectors', 'project_q': 'project_q', 'final_proj': 'project_hid', 'w2v_encoder.proj': 'lm_head', 'mask_emb': 'masked_spec_embed', 'pooling_layer.linear': 'projector', 'pooling_layer.projection': 'classifier', } __lowercase : str = [ 'lm_head', 'quantizer.weight_proj', 'quantizer.codevectors', 'project_q', 'project_hid', 'projector', 'classifier', ] def lowerCamelCase (_SCREAMING_SNAKE_CASE : List[Any] ): __a : List[str] = {} with open(_SCREAMING_SNAKE_CASE , 'r' ) as file: for line_number, line in enumerate(_SCREAMING_SNAKE_CASE ): __a : Tuple = line.strip() if line: __a : List[str] = line.split() __a : Tuple = line_number __a : Tuple = words[0] __a : List[Any] = value return result def lowerCamelCase (_SCREAMING_SNAKE_CASE : Tuple , _SCREAMING_SNAKE_CASE : List[Any] , _SCREAMING_SNAKE_CASE : Optional[Any] , _SCREAMING_SNAKE_CASE : int , _SCREAMING_SNAKE_CASE : List[Any] ): for attribute in key.split('.' ): __a : Tuple = getattr(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) __a : Optional[Any] = None for param_key in PARAM_MAPPING.keys(): if full_name.endswith(_SCREAMING_SNAKE_CASE ): __a : List[Any] = PARAM_MAPPING[full_name.split('.' )[-1]] __a : int = 'param' if weight_type is not None and weight_type != "param": __a : Optional[Any] = getattr(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ).shape elif weight_type is not None and weight_type == "param": __a : Union[str, Any] = hf_pointer for attribute in hf_param_name.split('.' ): __a : Optional[Any] = getattr(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) __a : Optional[int] = shape_pointer.shape # let's reduce dimension __a : str = value[0] else: __a : str = hf_pointer.shape if hf_shape != value.shape: raise ValueError( F"""Shape of hf {key + "." + weight_type if weight_type is not None else ""} is {hf_shape}, but should be""" F""" {value.shape} for {full_name}""" ) if weight_type == "weight": __a : Dict = value elif weight_type == "weight_g": __a : int = value elif weight_type == "weight_v": __a : Tuple = value elif weight_type == "bias": __a : Tuple = value elif weight_type == "param": for attribute in hf_param_name.split('.' ): __a : List[str] = getattr(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) __a : Any = value else: __a : List[Any] = value logger.info(F"""{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.""" ) def lowerCamelCase (_SCREAMING_SNAKE_CASE : List[str] , _SCREAMING_SNAKE_CASE : Union[str, Any] , _SCREAMING_SNAKE_CASE : Dict , _SCREAMING_SNAKE_CASE : Tuple , _SCREAMING_SNAKE_CASE : Tuple ): __a : Any = None for param_key in PARAM_MAPPING.keys(): if full_name.endswith(_SCREAMING_SNAKE_CASE ): __a : List[Any] = PARAM_MAPPING[full_name.split('.' )[-1]] __a : Any = 'param' if weight_type is not None and weight_type != "param": __a : str = '.'.join([key, weight_type] ) elif weight_type is not None and weight_type == "param": __a : Tuple = '.'.join([key, hf_param_name] ) else: __a : Optional[Any] = key __a : str = value if 'lm_head' in full_key else value[0] __lowercase : Dict = { 'W_a': 'linear_1.weight', 'W_b': 'linear_2.weight', 'b_a': 'linear_1.bias', 'b_b': 'linear_2.bias', 'ln_W': 'norm.weight', 'ln_b': 'norm.bias', } def lowerCamelCase (_SCREAMING_SNAKE_CASE : str , _SCREAMING_SNAKE_CASE : Dict , _SCREAMING_SNAKE_CASE : List[str]=None , _SCREAMING_SNAKE_CASE : Optional[Any]=None ): __a : Dict = False for key, mapped_key in MAPPING.items(): __a : Optional[int] = 'wav2vec2.' + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key if key in name or key.split('w2v_model.' )[-1] == name.split('.' )[0]: __a : str = True if "*" in mapped_key: __a : Optional[Any] = name.split(_SCREAMING_SNAKE_CASE )[0].split('.' )[-2] __a : List[str] = mapped_key.replace('*' , _SCREAMING_SNAKE_CASE ) if "weight_g" in name: __a : int = 'weight_g' elif "weight_v" in name: __a : Tuple = 'weight_v' elif "bias" in name: __a : Optional[Any] = 'bias' elif "weight" in name: # TODO: don't match quantizer.weight_proj __a : Optional[Any] = 'weight' else: __a : List[Any] = None if hf_dict is not None: rename_dict(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) else: set_recursively(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) return is_used return is_used def lowerCamelCase (_SCREAMING_SNAKE_CASE : Optional[Any] , _SCREAMING_SNAKE_CASE : Any , _SCREAMING_SNAKE_CASE : Any ): __a : Tuple = [] __a : Any = fairseq_model.state_dict() __a : str = hf_model.wavaveca.feature_extractor for name, value in fairseq_dict.items(): __a : List[str] = False if "conv_layers" in name: load_conv_layer( _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , hf_model.config.feat_extract_norm == 'group' , ) __a : Optional[Any] = True else: __a : Dict = load_wavaveca_layer(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) if not is_used: unused_weights.append(_SCREAMING_SNAKE_CASE ) logger.warning(F"""Unused weights: {unused_weights}""" ) def lowerCamelCase (_SCREAMING_SNAKE_CASE : Any , _SCREAMING_SNAKE_CASE : Optional[int] , _SCREAMING_SNAKE_CASE : str , _SCREAMING_SNAKE_CASE : Dict , _SCREAMING_SNAKE_CASE : Tuple ): __a : Dict = full_name.split('conv_layers.' )[-1] __a : Optional[Any] = name.split('.' ) __a : Optional[int] = int(items[0] ) __a : Union[str, Any] = int(items[1] ) if type_id == 0: if "bias" in name: if value.shape != feature_extractor.conv_layers[layer_id].conv.bias.data.shape: raise ValueError( F"""{full_name} has size {value.shape}, but""" F""" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found.""" ) __a : Optional[Any] = value logger.info(F"""Feat extract conv layer {layer_id} was initialized from {full_name}.""" ) elif "weight" in name: if value.shape != feature_extractor.conv_layers[layer_id].conv.weight.data.shape: raise ValueError( F"""{full_name} has size {value.shape}, but""" F""" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.""" ) __a : str = value logger.info(F"""Feat extract conv layer {layer_id} was initialized from {full_name}.""" ) elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm): if "bias" in name: if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape: raise ValueError( F"""{full_name} has size {value.shape}, but""" F""" {feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape} was found.""" ) __a : Tuple = value logger.info(F"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.""" ) elif "weight" in name: if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape: raise ValueError( F"""{full_name} has size {value.shape}, but""" F""" {feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape} was found.""" ) __a : Any = value logger.info(F"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.""" ) else: unused_weights.append(_SCREAMING_SNAKE_CASE ) @torch.no_grad() def lowerCamelCase (_SCREAMING_SNAKE_CASE : List[str] , _SCREAMING_SNAKE_CASE : Tuple , _SCREAMING_SNAKE_CASE : Dict=None , _SCREAMING_SNAKE_CASE : Dict=None , _SCREAMING_SNAKE_CASE : Optional[Any]=True , _SCREAMING_SNAKE_CASE : Any=False ): if config_path is not None: __a : Union[str, Any] = WavaVecaConfig.from_pretrained(_SCREAMING_SNAKE_CASE ) else: __a : List[str] = WavaVecaConfig() if is_seq_class: __a : List[Any] = read_txt_into_dict(_SCREAMING_SNAKE_CASE ) __a : List[str] = idalabel __a : int = WavaVecaForSequenceClassification(_SCREAMING_SNAKE_CASE ) __a : Any = WavaVecaFeatureExtractor( feature_size=1 , sampling_rate=16_000 , padding_value=0 , do_normalize=_SCREAMING_SNAKE_CASE , return_attention_mask=_SCREAMING_SNAKE_CASE , ) feature_extractor.save_pretrained(_SCREAMING_SNAKE_CASE ) elif is_finetuned: if dict_path: __a : Optional[Any] = Dictionary.load(_SCREAMING_SNAKE_CASE ) # important change bos & pad token id since CTC symbol is <pad> and # not <s> as in fairseq __a : Optional[int] = target_dict.pad_index __a : Dict = target_dict.bos_index __a : str = target_dict.eos_index __a : Union[str, Any] = len(target_dict.symbols ) __a : Optional[Any] = os.path.join(_SCREAMING_SNAKE_CASE , 'vocab.json' ) if not os.path.isdir(_SCREAMING_SNAKE_CASE ): logger.error('--pytorch_dump_folder_path ({}) should be a directory'.format(_SCREAMING_SNAKE_CASE ) ) return os.makedirs(_SCREAMING_SNAKE_CASE , exist_ok=_SCREAMING_SNAKE_CASE ) __a : int = target_dict.indices # fairseq has the <pad> and <s> switched __a : Tuple = 0 __a : Any = 1 with open(_SCREAMING_SNAKE_CASE , 'w' , encoding='utf-8' ) as vocab_handle: json.dump(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) __a : Optional[int] = WavaVecaCTCTokenizer( _SCREAMING_SNAKE_CASE , unk_token=target_dict.unk_word , pad_token=target_dict.pad_word , bos_token=target_dict.bos_word , eos_token=target_dict.eos_word , word_delimiter_token='|' , do_lower_case=_SCREAMING_SNAKE_CASE , ) __a : Any = True if config.feat_extract_norm == 'layer' else False __a : Optional[Any] = WavaVecaFeatureExtractor( feature_size=1 , sampling_rate=16_000 , padding_value=0 , do_normalize=_SCREAMING_SNAKE_CASE , return_attention_mask=_SCREAMING_SNAKE_CASE , ) __a : Dict = WavaVecaProcessor(feature_extractor=_SCREAMING_SNAKE_CASE , tokenizer=_SCREAMING_SNAKE_CASE ) processor.save_pretrained(_SCREAMING_SNAKE_CASE ) __a : Any = WavaVecaForCTC(_SCREAMING_SNAKE_CASE ) else: __a : Any = WavaVecaForPreTraining(_SCREAMING_SNAKE_CASE ) if is_finetuned or is_seq_class: __a , __a , __a : List[str] = fairseq.checkpoint_utils.load_model_ensemble_and_task( [checkpoint_path] , arg_overrides={'data': '/'.join(dict_path.split('/' )[:-1] )} ) else: __a : Tuple = argparse.Namespace(task='audio_pretraining' ) __a : Optional[Any] = fairseq.tasks.setup_task(_SCREAMING_SNAKE_CASE ) __a , __a , __a : List[Any] = fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path] , task=_SCREAMING_SNAKE_CASE ) __a : Optional[int] = model[0].eval() recursively_load_weights(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , not is_finetuned ) hf_wavavec.save_pretrained(_SCREAMING_SNAKE_CASE ) if __name__ == "__main__": __lowercase : Tuple = argparse.ArgumentParser() parser.add_argument('--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model.') parser.add_argument('--checkpoint_path', default=None, type=str, help='Path to fairseq checkpoint') parser.add_argument('--dict_path', default=None, type=str, help='Path to dict of fine-tuned model') parser.add_argument('--config_path', default=None, type=str, help='Path to hf config.json of model to convert') parser.add_argument( '--not_finetuned', action='store_true', help='Whether the model to convert is a fine-tuned model or not' ) parser.add_argument( '--is_seq_class', action='store_true', help='Whether the model to convert is a fine-tuned sequence classification model or not', ) __lowercase : List[Any] = parser.parse_args() __lowercase : Tuple = not args.not_finetuned and not args.is_seq_class convert_wavaveca_checkpoint( args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, is_finetuned, args.is_seq_class, )

'''simple docstring''' import shutil import tempfile import unittest from transformers import ClapFeatureExtractor, ClapProcessor, RobertaTokenizer, RobertaTokenizerFast from transformers.testing_utils import require_sentencepiece, require_torchaudio from .test_feature_extraction_clap import floats_list @require_torchaudio @require_sentencepiece class __UpperCamelCase ( unittest.TestCase ): def __UpperCAmelCase ( self ): '''simple docstring''' __a : Optional[Any] = 'laion/clap-htsat-unfused' __a : Optional[Any] = tempfile.mkdtemp() def __UpperCAmelCase ( self , **__a ): '''simple docstring''' return RobertaTokenizer.from_pretrained(self.checkpoint , **__a ) def __UpperCAmelCase ( self , **__a ): '''simple docstring''' return ClapFeatureExtractor.from_pretrained(self.checkpoint , **__a ) def __UpperCAmelCase ( self ): '''simple docstring''' shutil.rmtree(self.tmpdirname ) def __UpperCAmelCase ( self ): '''simple docstring''' __a : Any = self.get_tokenizer() __a : List[str] = self.get_feature_extractor() __a : Any = ClapProcessor(tokenizer=__a , feature_extractor=__a ) processor.save_pretrained(self.tmpdirname ) __a : Tuple = ClapProcessor.from_pretrained(self.tmpdirname ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer.get_vocab() ) self.assertIsInstance(processor.tokenizer , __a ) self.assertEqual(processor.feature_extractor.to_json_string() , feature_extractor.to_json_string() ) self.assertIsInstance(processor.feature_extractor , __a ) def __UpperCAmelCase ( self ): '''simple docstring''' __a : str = ClapProcessor(tokenizer=self.get_tokenizer() , feature_extractor=self.get_feature_extractor() ) processor.save_pretrained(self.tmpdirname ) __a : int = self.get_tokenizer(bos_token='(BOS)' , eos_token='(EOS)' ) __a : List[str] = self.get_feature_extractor(do_normalize=__a , padding_value=1.0 ) __a : Tuple = ClapProcessor.from_pretrained( self.tmpdirname , bos_token='(BOS)' , eos_token='(EOS)' , do_normalize=__a , padding_value=1.0 ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.tokenizer , __a ) self.assertEqual(processor.feature_extractor.to_json_string() , feature_extractor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.feature_extractor , __a ) def __UpperCAmelCase ( self ): '''simple docstring''' __a : str = self.get_feature_extractor() __a : int = self.get_tokenizer() __a : str = ClapProcessor(tokenizer=__a , feature_extractor=__a ) __a : int = floats_list((3, 1000) ) __a : str = feature_extractor(__a , return_tensors='np' ) __a : int = processor(audios=__a , return_tensors='np' ) for key in input_feat_extract.keys(): self.assertAlmostEqual(input_feat_extract[key].sum() , input_processor[key].sum() , delta=1E-2 ) def __UpperCAmelCase ( self ): '''simple docstring''' __a : Union[str, Any] = self.get_feature_extractor() __a : Any = self.get_tokenizer() __a : Any = ClapProcessor(tokenizer=__a , feature_extractor=__a ) __a : Union[str, Any] = 'This is a test string' __a : Union[str, Any] = processor(text=__a ) __a : Tuple = tokenizer(__a ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key] ) def __UpperCAmelCase ( self ): '''simple docstring''' __a : str = self.get_feature_extractor() __a : str = self.get_tokenizer() __a : List[str] = ClapProcessor(tokenizer=__a , feature_extractor=__a ) __a : Dict = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] __a : Optional[int] = processor.batch_decode(__a ) __a : Optional[Any] = tokenizer.batch_decode(__a ) self.assertListEqual(__a , __a ) def __UpperCAmelCase ( self ): '''simple docstring''' __a : Optional[Any] = self.get_feature_extractor() __a : Optional[int] = self.get_tokenizer() __a : int = ClapProcessor(tokenizer=__a , feature_extractor=__a ) self.assertListEqual( processor.model_input_names[2:] , feature_extractor.model_input_names , msg='`processor` and `feature_extractor` model input names do not match' , )

'''simple docstring''' from ...configuration_utils import PretrainedConfig from ...utils import logging __a = logging.get_logger(__name__) __a = { 'abeja/gpt-neox-japanese-2.7b': 'https://huggingface.co/abeja/gpt-neox-japanese-2.7b/resolve/main/config.json', } class A__ ( UpperCamelCase__ ): """simple docstring""" UpperCamelCase_ : List[str] = """gpt_neox_japanese""" def __init__( self : List[Any] , lowerCAmelCase__ : str=3_2_0_0_0 , lowerCAmelCase__ : int=2_5_6_0 , lowerCAmelCase__ : Dict=3_2 , lowerCAmelCase__ : List[str]=3_2 , lowerCAmelCase__ : str=4 , lowerCAmelCase__ : List[str]="gelu" , lowerCAmelCase__ : List[str]=1.00 , lowerCAmelCase__ : Union[str, Any]=1_0_0_0_0 , lowerCAmelCase__ : str=2_0_4_8 , lowerCAmelCase__ : Tuple=0.02 , lowerCAmelCase__ : List[Any]=1e-5 , lowerCAmelCase__ : List[str]=True , lowerCAmelCase__ : str=3_1_9_9_6 , lowerCAmelCase__ : Optional[Any]=3_1_9_9_9 , lowerCAmelCase__ : Any=0.1 , lowerCAmelCase__ : List[Any]=0.0 , **lowerCAmelCase__ : str , ) -> Tuple: """simple docstring""" super().__init__(bos_token_id=__a , eos_token_id=__a , **__a ) _UpperCAmelCase : Tuple = vocab_size _UpperCAmelCase : Dict = max_position_embeddings _UpperCAmelCase : Any = hidden_size _UpperCAmelCase : Union[str, Any] = num_hidden_layers _UpperCAmelCase : int = num_attention_heads _UpperCAmelCase : List[Any] = intermediate_multiple_size _UpperCAmelCase : Union[str, Any] = hidden_act _UpperCAmelCase : Dict = rotary_pct _UpperCAmelCase : List[str] = rotary_emb_base _UpperCAmelCase : Optional[int] = initializer_range _UpperCAmelCase : Tuple = layer_norm_eps _UpperCAmelCase : Optional[Any] = use_cache _UpperCAmelCase : int = attention_dropout _UpperCAmelCase : List[Any] = hidden_dropout

'''simple docstring''' from ...configuration_utils import PretrainedConfig from ...utils import logging SCREAMING_SNAKE_CASE_: Dict =logging.get_logger(__name__) SCREAMING_SNAKE_CASE_: Tuple ={} class __A ( UpperCamelCase__ ): a__ : int = """llama""" a__ : Any = ["""past_key_values"""] def __init__(self : List[str] , __a : List[str]=32000 , __a : Tuple=4096 , __a : List[Any]=11008 , __a : Dict=32 , __a : Tuple=32 , __a : Any=None , __a : Any="silu" , __a : List[Any]=2048 , __a : List[Any]=0.02 , __a : str=1E-6 , __a : Optional[Any]=True , __a : Union[str, Any]=0 , __a : Any=1 , __a : Dict=2 , __a : Dict=1 , __a : str=False , __a : str=None , **__a : Optional[Any] , ): UpperCAmelCase_ = vocab_size UpperCAmelCase_ = max_position_embeddings UpperCAmelCase_ = hidden_size UpperCAmelCase_ = intermediate_size UpperCAmelCase_ = num_hidden_layers UpperCAmelCase_ = num_attention_heads # for backward compatibility if num_key_value_heads is None: UpperCAmelCase_ = num_attention_heads UpperCAmelCase_ = num_key_value_heads UpperCAmelCase_ = hidden_act UpperCAmelCase_ = initializer_range UpperCAmelCase_ = rms_norm_eps UpperCAmelCase_ = pretraining_tp UpperCAmelCase_ = use_cache UpperCAmelCase_ = rope_scaling self._rope_scaling_validation() super().__init__( pad_token_id=__a , bos_token_id=__a , eos_token_id=__a , tie_word_embeddings=__a , **__a , ) def _lowercase (self : List[str] ): if self.rope_scaling is None: return if not isinstance(self.rope_scaling , __a ) or len(self.rope_scaling ) != 2: raise ValueError( "`rope_scaling` must be a dictionary with with two fields, `name` and `factor`, " f"""got {self.rope_scaling}""" ) UpperCAmelCase_ = self.rope_scaling.get("type" , __a ) UpperCAmelCase_ = self.rope_scaling.get("factor" , __a ) if rope_scaling_type is None or rope_scaling_type not in ["linear", "dynamic"]: raise ValueError( f"""`rope_scaling`'s name field must be one of ['linear', 'dynamic'], got {rope_scaling_type}""" ) if rope_scaling_factor is None or not isinstance(__a , __a ) or rope_scaling_factor <= 1.0: raise ValueError(f"""`rope_scaling`'s factor field must be an float > 1, got {rope_scaling_factor}""" )

from __future__ import annotations def lowerCamelCase__ ( UpperCamelCase__ : Dict ) -> bool: '''simple docstring''' _snake_case = str(__lowerCAmelCase ) return n == n[::-1] def lowerCamelCase__ ( UpperCamelCase__ : Optional[int] = 1_000_000 ) -> List[Any]: '''simple docstring''' _snake_case = 0 for i in range(1 , __lowerCAmelCase ): if is_palindrome(__lowerCAmelCase ) and is_palindrome(bin(__lowerCAmelCase ).split('b' )[1] ): total += i return total if __name__ == "__main__": print(solution(int(str(input().strip()))))

import math import torch from torch import nn from ..configuration_utils import ConfigMixin, register_to_config from .attention_processor import Attention from .embeddings import get_timestep_embedding from .modeling_utils import ModelMixin class UpperCamelCase_ ( _lowerCamelCase , _lowerCamelCase ): @register_to_config def __init__( self , lowerCAmelCase_ = 128 , lowerCAmelCase_ = 256 , lowerCAmelCase_ = 20_00.0 , lowerCAmelCase_ = 768 , lowerCAmelCase_ = 12 , lowerCAmelCase_ = 12 , lowerCAmelCase_ = 64 , lowerCAmelCase_ = 2048 , lowerCAmelCase_ = 0.1 , ) -> Union[str, Any]: super().__init__() _snake_case = nn.Sequential( nn.Linear(lowerCAmelCase_ , d_model * 4 , bias=lowerCAmelCase_ ) , nn.SiLU() , nn.Linear(d_model * 4 , d_model * 4 , bias=lowerCAmelCase_ ) , nn.SiLU() , ) _snake_case = nn.Embedding(lowerCAmelCase_ , lowerCAmelCase_ ) _snake_case = False _snake_case = nn.Linear(lowerCAmelCase_ , lowerCAmelCase_ , bias=lowerCAmelCase_ ) _snake_case = nn.Dropout(p=lowerCAmelCase_ ) _snake_case = nn.ModuleList() for lyr_num in range(lowerCAmelCase_ ): # FiLM conditional T5 decoder _snake_case = DecoderLayer(d_model=lowerCAmelCase_ , d_kv=lowerCAmelCase_ , num_heads=lowerCAmelCase_ , d_ff=lowerCAmelCase_ , dropout_rate=lowerCAmelCase_ ) self.decoders.append(lowerCAmelCase_ ) _snake_case = TaLayerNorm(lowerCAmelCase_ ) _snake_case = nn.Dropout(p=lowerCAmelCase_ ) _snake_case = nn.Linear(lowerCAmelCase_ , lowerCAmelCase_ , bias=lowerCAmelCase_ ) def lowerCAmelCase ( self , lowerCAmelCase_ , lowerCAmelCase_ ) -> Tuple: _snake_case = torch.mul(query_input.unsqueeze(-1 ) , key_input.unsqueeze(-2 ) ) return mask.unsqueeze(-3 ) def lowerCAmelCase ( self , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ ) -> Optional[Any]: _snake_case , _snake_case , _snake_case = decoder_input_tokens.shape assert decoder_noise_time.shape == (batch,) # decoder_noise_time is in [0, 1), so rescale to expected timing range. _snake_case = get_timestep_embedding( decoder_noise_time * self.config.max_decoder_noise_time , embedding_dim=self.config.d_model , max_period=self.config.max_decoder_noise_time , ).to(dtype=self.dtype ) _snake_case = self.conditioning_emb(lowerCAmelCase_ ).unsqueeze(1 ) assert conditioning_emb.shape == (batch, 1, self.config.d_model * 4) _snake_case = decoder_input_tokens.shape[1] # If we want to use relative positions for audio context, we can just offset # this sequence by the length of encodings_and_masks. _snake_case = torch.broadcast_to( torch.arange(lowerCAmelCase_ , device=decoder_input_tokens.device ) , (batch, seq_length) , ) _snake_case = self.position_encoding(lowerCAmelCase_ ) _snake_case = self.continuous_inputs_projection(lowerCAmelCase_ ) inputs += position_encodings _snake_case = self.dropout(lowerCAmelCase_ ) # decoder: No padding present. _snake_case = torch.ones( decoder_input_tokens.shape[:2] , device=decoder_input_tokens.device , dtype=inputs.dtype ) # Translate encoding masks to encoder-decoder masks. _snake_case = [(x, self.encoder_decoder_mask(lowerCAmelCase_ , lowerCAmelCase_ )) for x, y in encodings_and_masks] # cross attend style: concat encodings _snake_case = torch.cat([x[0] for x in encodings_and_encdec_masks] , dim=1 ) _snake_case = torch.cat([x[1] for x in encodings_and_encdec_masks] , dim=-1 ) for lyr in self.decoders: _snake_case = lyr( lowerCAmelCase_ , conditioning_emb=lowerCAmelCase_ , encoder_hidden_states=lowerCAmelCase_ , encoder_attention_mask=lowerCAmelCase_ , )[0] _snake_case = self.decoder_norm(lowerCAmelCase_ ) _snake_case = self.post_dropout(lowerCAmelCase_ ) _snake_case = self.spec_out(lowerCAmelCase_ ) return spec_out class UpperCamelCase_ ( nn.Module ): def __init__( self , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_=1E-6 ) -> Tuple: super().__init__() _snake_case = nn.ModuleList() # cond self attention: layer 0 self.layer.append( TaLayerSelfAttentionCond(d_model=lowerCAmelCase_ , d_kv=lowerCAmelCase_ , num_heads=lowerCAmelCase_ , dropout_rate=lowerCAmelCase_ ) ) # cross attention: layer 1 self.layer.append( TaLayerCrossAttention( d_model=lowerCAmelCase_ , d_kv=lowerCAmelCase_ , num_heads=lowerCAmelCase_ , dropout_rate=lowerCAmelCase_ , layer_norm_epsilon=lowerCAmelCase_ , ) ) # Film Cond MLP + dropout: last layer self.layer.append( TaLayerFFCond(d_model=lowerCAmelCase_ , d_ff=lowerCAmelCase_ , dropout_rate=lowerCAmelCase_ , layer_norm_epsilon=lowerCAmelCase_ ) ) def lowerCAmelCase ( self , lowerCAmelCase_ , lowerCAmelCase_=None , lowerCAmelCase_=None , lowerCAmelCase_=None , lowerCAmelCase_=None , lowerCAmelCase_=None , ) -> Tuple: _snake_case = self.layer[0]( lowerCAmelCase_ , conditioning_emb=lowerCAmelCase_ , attention_mask=lowerCAmelCase_ , ) if encoder_hidden_states is not None: _snake_case = torch.where(encoder_attention_mask > 0 , 0 , -1E10 ).to( encoder_hidden_states.dtype ) _snake_case = self.layer[1]( lowerCAmelCase_ , key_value_states=lowerCAmelCase_ , attention_mask=lowerCAmelCase_ , ) # Apply Film Conditional Feed Forward layer _snake_case = self.layer[-1](lowerCAmelCase_ , lowerCAmelCase_ ) return (hidden_states,) class UpperCamelCase_ ( nn.Module ): def __init__( self , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ ) -> Tuple: super().__init__() _snake_case = TaLayerNorm(lowerCAmelCase_ ) _snake_case = TaFiLMLayer(in_features=d_model * 4 , out_features=lowerCAmelCase_ ) _snake_case = Attention(query_dim=lowerCAmelCase_ , heads=lowerCAmelCase_ , dim_head=lowerCAmelCase_ , out_bias=lowerCAmelCase_ , scale_qk=lowerCAmelCase_ ) _snake_case = nn.Dropout(lowerCAmelCase_ ) def lowerCAmelCase ( self , lowerCAmelCase_ , lowerCAmelCase_=None , lowerCAmelCase_=None , ) -> str: # pre_self_attention_layer_norm _snake_case = self.layer_norm(lowerCAmelCase_ ) if conditioning_emb is not None: _snake_case = self.FiLMLayer(lowerCAmelCase_ , lowerCAmelCase_ ) # Self-attention block _snake_case = self.attention(lowerCAmelCase_ ) _snake_case = hidden_states + self.dropout(lowerCAmelCase_ ) return hidden_states class UpperCamelCase_ ( nn.Module ): def __init__( self , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ ) -> str: super().__init__() _snake_case = Attention(query_dim=lowerCAmelCase_ , heads=lowerCAmelCase_ , dim_head=lowerCAmelCase_ , out_bias=lowerCAmelCase_ , scale_qk=lowerCAmelCase_ ) _snake_case = TaLayerNorm(lowerCAmelCase_ , eps=lowerCAmelCase_ ) _snake_case = nn.Dropout(lowerCAmelCase_ ) def lowerCAmelCase ( self , lowerCAmelCase_ , lowerCAmelCase_=None , lowerCAmelCase_=None , ) -> Dict: _snake_case = self.layer_norm(lowerCAmelCase_ ) _snake_case = self.attention( lowerCAmelCase_ , encoder_hidden_states=lowerCAmelCase_ , attention_mask=attention_mask.squeeze(1 ) , ) _snake_case = hidden_states + self.dropout(lowerCAmelCase_ ) return layer_output class UpperCamelCase_ ( nn.Module ): def __init__( self , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ ) -> List[str]: super().__init__() _snake_case = TaDenseGatedActDense(d_model=lowerCAmelCase_ , d_ff=lowerCAmelCase_ , dropout_rate=lowerCAmelCase_ ) _snake_case = TaFiLMLayer(in_features=d_model * 4 , out_features=lowerCAmelCase_ ) _snake_case = TaLayerNorm(lowerCAmelCase_ , eps=lowerCAmelCase_ ) _snake_case = nn.Dropout(lowerCAmelCase_ ) def lowerCAmelCase ( self , lowerCAmelCase_ , lowerCAmelCase_=None ) -> Union[str, Any]: _snake_case = self.layer_norm(lowerCAmelCase_ ) if conditioning_emb is not None: _snake_case = self.film(lowerCAmelCase_ , lowerCAmelCase_ ) _snake_case = self.DenseReluDense(lowerCAmelCase_ ) _snake_case = hidden_states + self.dropout(lowerCAmelCase_ ) return hidden_states class UpperCamelCase_ ( nn.Module ): def __init__( self , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ ) -> Union[str, Any]: super().__init__() _snake_case = nn.Linear(lowerCAmelCase_ , lowerCAmelCase_ , bias=lowerCAmelCase_ ) _snake_case = nn.Linear(lowerCAmelCase_ , lowerCAmelCase_ , bias=lowerCAmelCase_ ) _snake_case = nn.Linear(lowerCAmelCase_ , lowerCAmelCase_ , bias=lowerCAmelCase_ ) _snake_case = nn.Dropout(lowerCAmelCase_ ) _snake_case = NewGELUActivation() def lowerCAmelCase ( self , lowerCAmelCase_ ) -> Any: _snake_case = self.act(self.wi_a(lowerCAmelCase_ ) ) _snake_case = self.wi_a(lowerCAmelCase_ ) _snake_case = hidden_gelu * hidden_linear _snake_case = self.dropout(lowerCAmelCase_ ) _snake_case = self.wo(lowerCAmelCase_ ) return hidden_states class UpperCamelCase_ ( nn.Module ): def __init__( self , lowerCAmelCase_ , lowerCAmelCase_=1E-6 ) -> str: super().__init__() _snake_case = nn.Parameter(torch.ones(lowerCAmelCase_ ) ) _snake_case = eps def lowerCAmelCase ( self , lowerCAmelCase_ ) -> int: # T5 uses a layer_norm which only scales and doesn't shift, which is also known as Root Mean # Square Layer Normalization https://arxiv.org/abs/1910.07467 thus variance is calculated # w/o mean and there is no bias. Additionally we want to make sure that the accumulation for # half-precision inputs is done in fp32 _snake_case = hidden_states.to(torch.floataa ).pow(2 ).mean(-1 , keepdim=lowerCAmelCase_ ) _snake_case = hidden_states * torch.rsqrt(variance + self.variance_epsilon ) # convert into half-precision if necessary if self.weight.dtype in [torch.floataa, torch.bfloataa]: _snake_case = hidden_states.to(self.weight.dtype ) return self.weight * hidden_states class UpperCamelCase_ ( nn.Module ): def lowerCAmelCase ( self , lowerCAmelCase_ ) -> torch.Tensor: return 0.5 * input * (1.0 + torch.tanh(math.sqrt(2.0 / math.pi ) * (input + 0.04_47_15 * torch.pow(lowerCAmelCase_ , 3.0 )) )) class UpperCamelCase_ ( nn.Module ): def __init__( self , lowerCAmelCase_ , lowerCAmelCase_ ) -> Any: super().__init__() _snake_case = nn.Linear(lowerCAmelCase_ , out_features * 2 , bias=lowerCAmelCase_ ) def lowerCAmelCase ( self , lowerCAmelCase_ , lowerCAmelCase_ ) -> Optional[Any]: _snake_case = self.scale_bias(lowerCAmelCase_ ) _snake_case , _snake_case = torch.chunk(lowerCAmelCase_ , 2 , -1 ) _snake_case = x * (1 + scale) + shift return x

"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_tokenizers_available, is_torch_available, ) __lowerCamelCase = { "configuration_lxmert": ["LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP", "LxmertConfig"], "tokenization_lxmert": ["LxmertTokenizer"], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __lowerCamelCase = ["LxmertTokenizerFast"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __lowerCamelCase = [ "LxmertEncoder", "LxmertForPreTraining", "LxmertForQuestionAnswering", "LxmertModel", "LxmertPreTrainedModel", "LxmertVisualFeatureEncoder", "LxmertXLayer", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __lowerCamelCase = [ "TF_LXMERT_PRETRAINED_MODEL_ARCHIVE_LIST", "TFLxmertForPreTraining", "TFLxmertMainLayer", "TFLxmertModel", "TFLxmertPreTrainedModel", "TFLxmertVisualFeatureEncoder", ] if TYPE_CHECKING: from .configuration_lxmert import LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, LxmertConfig from .tokenization_lxmert import LxmertTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_lxmert_fast import LxmertTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_lxmert import ( LxmertEncoder, LxmertForPreTraining, LxmertForQuestionAnswering, LxmertModel, LxmertPreTrainedModel, LxmertVisualFeatureEncoder, LxmertXLayer, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_lxmert import ( TF_LXMERT_PRETRAINED_MODEL_ARCHIVE_LIST, TFLxmertForPreTraining, TFLxmertMainLayer, TFLxmertModel, TFLxmertPreTrainedModel, TFLxmertVisualFeatureEncoder, ) else: import sys __lowerCamelCase = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)

"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available __lowerCamelCase = { "configuration_chinese_clip": [ "CHINESE_CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP", "ChineseCLIPConfig", "ChineseCLIPOnnxConfig", "ChineseCLIPTextConfig", "ChineseCLIPVisionConfig", ], "processing_chinese_clip": ["ChineseCLIPProcessor"], } try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __lowerCamelCase = ["ChineseCLIPFeatureExtractor"] __lowerCamelCase = ["ChineseCLIPImageProcessor"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __lowerCamelCase = [ "CHINESE_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST", "ChineseCLIPModel", "ChineseCLIPPreTrainedModel", "ChineseCLIPTextModel", "ChineseCLIPVisionModel", ] if TYPE_CHECKING: from .configuration_chinese_clip import ( CHINESE_CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP, ChineseCLIPConfig, ChineseCLIPOnnxConfig, ChineseCLIPTextConfig, ChineseCLIPVisionConfig, ) from .processing_chinese_clip import ChineseCLIPProcessor try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_chinese_clip import ChineseCLIPFeatureExtractor, ChineseCLIPImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_chinese_clip import ( CHINESE_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST, ChineseCLIPModel, ChineseCLIPPreTrainedModel, ChineseCLIPTextModel, ChineseCLIPVisionModel, ) else: import sys __lowerCamelCase = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)

import logging from pathlib import Path import numpy as np import pytorch_lightning as pl import torch from pytorch_lightning.callbacks import EarlyStopping, ModelCheckpoint from pytorch_lightning.utilities import rank_zero_only from utils_rag import save_json def __magic_name__ ( __a : Tuple ): '''simple docstring''' UpperCamelCase__ = filter(lambda __a : p.requires_grad , model.parameters() ) UpperCamelCase__ = sum([np.prod(p.size() ) for p in model_parameters] ) return params lowerCamelCase_ = logging.getLogger(__name__) def __magic_name__ ( __a : int , __a : List[str] ): '''simple docstring''' if metric == "rouge2": UpperCamelCase__ = """{val_avg_rouge2:.4f}-{step_count}""" elif metric == "bleu": UpperCamelCase__ = """{val_avg_bleu:.4f}-{step_count}""" elif metric == "em": UpperCamelCase__ = """{val_avg_em:.4f}-{step_count}""" else: raise NotImplementedError( f"seq2seq callbacks only support rouge2 and bleu, got {metric}, You can make your own by adding to this" """ function.""" ) UpperCamelCase__ = ModelCheckpoint( dirpath=__a , filename=__a , monitor=f"val_{metric}" , mode="""max""" , save_top_k=3 , every_n_epochs=1 , ) return checkpoint_callback def __magic_name__ ( __a : Optional[Any] , __a : str ): '''simple docstring''' return EarlyStopping( monitor=f"val_{metric}" , mode="""min""" if """loss""" in metric else """max""" , patience=__a , verbose=__a , ) class __A( pl.Callback ): """simple docstring""" def UpperCAmelCase_ (self , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ): UpperCamelCase__ = {F"lr_group_{i}": param["""lr"""] for i, param in enumerate(pl_module.trainer.optimizers[0].param_groups )} pl_module.logger.log_metrics(SCREAMING_SNAKE_CASE_ ) @rank_zero_only def UpperCAmelCase_ (self , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_=True ): logger.info(F"***** {type_path} results at step {trainer.global_step:05d} *****" ) UpperCamelCase__ = trainer.callback_metrics trainer.logger.log_metrics({k: v for k, v in metrics.items() if k not in ["""log""", """progress_bar""", """preds"""]} ) # Log results UpperCamelCase__ = Path(pl_module.hparams.output_dir ) if type_path == "test": UpperCamelCase__ = od / """test_results.txt""" UpperCamelCase__ = od / """test_generations.txt""" else: # this never gets hit. I prefer not to save intermediate generations, and results are in metrics.json # If people want this it will be easy enough to add back. UpperCamelCase__ = od / F"{type_path}_results/{trainer.global_step:05d}.txt" UpperCamelCase__ = od / F"{type_path}_generations/{trainer.global_step:05d}.txt" results_file.parent.mkdir(exist_ok=SCREAMING_SNAKE_CASE_ ) generations_file.parent.mkdir(exist_ok=SCREAMING_SNAKE_CASE_ ) with open(SCREAMING_SNAKE_CASE_ , """a+""" ) as writer: for key in sorted(SCREAMING_SNAKE_CASE_ ): if key in ["log", "progress_bar", "preds"]: continue UpperCamelCase__ = metrics[key] if isinstance(SCREAMING_SNAKE_CASE_ , torch.Tensor ): UpperCamelCase__ = val.item() UpperCamelCase__ = F"{key}: {val:.6f}\n" writer.write(SCREAMING_SNAKE_CASE_ ) if not save_generations: return if "preds" in metrics: UpperCamelCase__ = """\n""".join(metrics["""preds"""] ) generations_file.open("""w+""" ).write(SCREAMING_SNAKE_CASE_ ) @rank_zero_only def UpperCAmelCase_ (self , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ): try: UpperCamelCase__ = pl_module.model.model.num_parameters() except AttributeError: UpperCamelCase__ = pl_module.model.num_parameters() UpperCamelCase__ = count_trainable_parameters(SCREAMING_SNAKE_CASE_ ) # mp stands for million parameters trainer.logger.log_metrics({"""n_params""": npars, """mp""": npars / 1E6, """grad_mp""": n_trainable_pars / 1E6} ) @rank_zero_only def UpperCAmelCase_ (self , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ): save_json(pl_module.metrics , pl_module.metrics_save_path ) return self._write_logs(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , """test""" ) @rank_zero_only def UpperCAmelCase_ (self , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ): save_json(pl_module.metrics , pl_module.metrics_save_path ) # Uncommenting this will save val generations # return self._write_logs(trainer, pl_module, "valid")

import hashlib import unittest from typing import Dict import numpy as np from transformers import ( MODEL_FOR_MASK_GENERATION_MAPPING, TF_MODEL_FOR_MASK_GENERATION_MAPPING, is_vision_available, pipeline, ) from transformers.pipelines import MaskGenerationPipeline from transformers.testing_utils import ( is_pipeline_test, nested_simplify, require_tf, require_torch, require_vision, slow, ) if is_vision_available(): from PIL import Image else: class __A: """simple docstring""" @staticmethod def UpperCAmelCase_ (*SCREAMING_SNAKE_CASE_ , **SCREAMING_SNAKE_CASE_ ): pass def __magic_name__ ( __a : Image ): '''simple docstring''' UpperCamelCase__ = hashlib.mda(image.tobytes() ) return m.hexdigest()[:10] def __magic_name__ ( __a : Image ): '''simple docstring''' UpperCamelCase__ = np.array(__a ) UpperCamelCase__ = npimg.shape return {"hash": hashimage(__a ), "shape": shape} @is_pipeline_test @require_vision @require_torch class __A( unittest.TestCase ): """simple docstring""" SCREAMING_SNAKE_CASE__ = dict( (list(MODEL_FOR_MASK_GENERATION_MAPPING.items() ) if MODEL_FOR_MASK_GENERATION_MAPPING else []) ) SCREAMING_SNAKE_CASE__ = dict( (list(TF_MODEL_FOR_MASK_GENERATION_MAPPING.items() ) if TF_MODEL_FOR_MASK_GENERATION_MAPPING else []) ) def UpperCAmelCase_ (self , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ): UpperCamelCase__ = MaskGenerationPipeline(model=SCREAMING_SNAKE_CASE_ , image_processor=SCREAMING_SNAKE_CASE_ ) return image_segmenter, [ "./tests/fixtures/tests_samples/COCO/000000039769.png", "./tests/fixtures/tests_samples/COCO/000000039769.png", ] def UpperCAmelCase_ (self , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ): pass @require_tf @unittest.skip("""Image segmentation not implemented in TF""" ) def UpperCAmelCase_ (self ): pass @slow @require_torch def UpperCAmelCase_ (self ): UpperCamelCase__ = pipeline("""mask-generation""" , model="""facebook/sam-vit-huge""" ) UpperCamelCase__ = image_segmenter("""http://images.cocodataset.org/val2017/000000039769.jpg""" , points_per_batch=2_56 ) # Shortening by hashing UpperCamelCase__ = [] for i, o in enumerate(outputs["""masks"""] ): new_outupt += [{"mask": mask_to_test_readable(SCREAMING_SNAKE_CASE_ ), "scores": outputs["scores"][i]}] # fmt: off self.assertEqual( nested_simplify(SCREAMING_SNAKE_CASE_ , decimals=4 ) , [ {"""mask""": {"""hash""": """115ad19f5f""", """shape""": (4_80, 6_40)}, """scores""": 1.0444}, {"""mask""": {"""hash""": """6affa964c6""", """shape""": (4_80, 6_40)}, """scores""": 1.021}, {"""mask""": {"""hash""": """dfe28a0388""", """shape""": (4_80, 6_40)}, """scores""": 1.0167}, {"""mask""": {"""hash""": """c0a5f4a318""", """shape""": (4_80, 6_40)}, """scores""": 1.0132}, {"""mask""": {"""hash""": """fe8065c197""", """shape""": (4_80, 6_40)}, """scores""": 1.0053}, {"""mask""": {"""hash""": """e2d0b7a0b7""", """shape""": (4_80, 6_40)}, """scores""": 0.9967}, {"""mask""": {"""hash""": """453c7844bd""", """shape""": (4_80, 6_40)}, """scores""": 0.993}, {"""mask""": {"""hash""": """3d44f2926d""", """shape""": (4_80, 6_40)}, """scores""": 0.9909}, {"""mask""": {"""hash""": """64033ddc3f""", """shape""": (4_80, 6_40)}, """scores""": 0.9879}, {"""mask""": {"""hash""": """801064ff79""", """shape""": (4_80, 6_40)}, """scores""": 0.9834}, {"""mask""": {"""hash""": """6172f276ef""", """shape""": (4_80, 6_40)}, """scores""": 0.9716}, {"""mask""": {"""hash""": """b49e60e084""", """shape""": (4_80, 6_40)}, """scores""": 0.9612}, {"""mask""": {"""hash""": """a811e775fd""", """shape""": (4_80, 6_40)}, """scores""": 0.9599}, {"""mask""": {"""hash""": """a6a8ebcf4b""", """shape""": (4_80, 6_40)}, """scores""": 0.9552}, {"""mask""": {"""hash""": """9d8257e080""", """shape""": (4_80, 6_40)}, """scores""": 0.9532}, {"""mask""": {"""hash""": """32de6454a8""", """shape""": (4_80, 6_40)}, """scores""": 0.9516}, {"""mask""": {"""hash""": """af3d4af2c8""", """shape""": (4_80, 6_40)}, """scores""": 0.9499}, {"""mask""": {"""hash""": """3c6db475fb""", """shape""": (4_80, 6_40)}, """scores""": 0.9483}, {"""mask""": {"""hash""": """c290813fb9""", """shape""": (4_80, 6_40)}, """scores""": 0.9464}, {"""mask""": {"""hash""": """b6f0b8f606""", """shape""": (4_80, 6_40)}, """scores""": 0.943}, {"""mask""": {"""hash""": """92ce16bfdf""", """shape""": (4_80, 6_40)}, """scores""": 0.943}, {"""mask""": {"""hash""": """c749b25868""", """shape""": (4_80, 6_40)}, """scores""": 0.9408}, {"""mask""": {"""hash""": """efb6cab859""", """shape""": (4_80, 6_40)}, """scores""": 0.9335}, {"""mask""": {"""hash""": """1ff2eafb30""", """shape""": (4_80, 6_40)}, """scores""": 0.9326}, {"""mask""": {"""hash""": """788b798e24""", """shape""": (4_80, 6_40)}, """scores""": 0.9262}, {"""mask""": {"""hash""": """abea804f0e""", """shape""": (4_80, 6_40)}, """scores""": 0.8999}, {"""mask""": {"""hash""": """7b9e8ddb73""", """shape""": (4_80, 6_40)}, """scores""": 0.8986}, {"""mask""": {"""hash""": """cd24047c8a""", """shape""": (4_80, 6_40)}, """scores""": 0.8984}, {"""mask""": {"""hash""": """6943e6bcbd""", """shape""": (4_80, 6_40)}, """scores""": 0.8873}, {"""mask""": {"""hash""": """b5f47c9191""", """shape""": (4_80, 6_40)}, """scores""": 0.8871} ] , ) # fmt: on @require_torch @slow def UpperCAmelCase_ (self ): UpperCamelCase__ = """facebook/sam-vit-huge""" UpperCamelCase__ = pipeline("""mask-generation""" , model=SCREAMING_SNAKE_CASE_ ) UpperCamelCase__ = image_segmenter( """http://images.cocodataset.org/val2017/000000039769.jpg""" , pred_iou_thresh=1 , points_per_batch=2_56 ) # Shortening by hashing UpperCamelCase__ = [] for i, o in enumerate(outputs["""masks"""] ): new_outupt += [{"mask": mask_to_test_readable(SCREAMING_SNAKE_CASE_ ), "scores": outputs["scores"][i]}] self.assertEqual( nested_simplify(SCREAMING_SNAKE_CASE_ , decimals=4 ) , [ {"""mask""": {"""hash""": """115ad19f5f""", """shape""": (4_80, 6_40)}, """scores""": 1.0444}, {"""mask""": {"""hash""": """6affa964c6""", """shape""": (4_80, 6_40)}, """scores""": 1.0210}, {"""mask""": {"""hash""": """dfe28a0388""", """shape""": (4_80, 6_40)}, """scores""": 1.0167}, {"""mask""": {"""hash""": """c0a5f4a318""", """shape""": (4_80, 6_40)}, """scores""": 1.0132}, {"""mask""": {"""hash""": """fe8065c197""", """shape""": (4_80, 6_40)}, """scores""": 1.0053}, ] , )

"""simple docstring""" import itertools import math def lowerCamelCase__ ( _lowerCamelCase : int ) -> bool: if 1 < number < 4: # 2 and 3 are primes return True elif number < 2 or number % 2 == 0 or number % 3 == 0: # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes return False # All primes number are in format of 6k +/- 1 for i in range(5 , int(math.sqrt(_lowerCamelCase ) + 1 ) , 6 ): if number % i == 0 or number % (i + 2) == 0: return False return True def lowerCamelCase__ ( ) -> Union[str, Any]: lowerCamelCase_ = 2 while True: if is_prime(_lowerCamelCase ): yield num num += 1 def lowerCamelCase__ ( _lowerCamelCase : int = 10001 ) -> int: return next(itertools.islice(prime_generator() , nth - 1 , _lowerCamelCase ) ) if __name__ == "__main__": print(F'''{solution() = }''')

"""simple docstring""" from typing import Any, Callable, Dict, List, Optional, Union import torch from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer from diffusers import ( AutoencoderKL, DDIMScheduler, DiffusionPipeline, LMSDiscreteScheduler, PNDMScheduler, StableDiffusionPipeline, UNetaDConditionModel, ) from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker _SCREAMING_SNAKE_CASE : Union[str, Any] = '''CompVis/stable-diffusion-v1-1''' _SCREAMING_SNAKE_CASE : Optional[Any] = '''CompVis/stable-diffusion-v1-2''' _SCREAMING_SNAKE_CASE : int = '''CompVis/stable-diffusion-v1-3''' _SCREAMING_SNAKE_CASE : str = '''CompVis/stable-diffusion-v1-4''' class a ( __snake_case ): def __init__( self : int , __SCREAMING_SNAKE_CASE : AutoencoderKL , __SCREAMING_SNAKE_CASE : CLIPTextModel , __SCREAMING_SNAKE_CASE : CLIPTokenizer , __SCREAMING_SNAKE_CASE : UNetaDConditionModel , __SCREAMING_SNAKE_CASE : Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler] , __SCREAMING_SNAKE_CASE : StableDiffusionSafetyChecker , __SCREAMING_SNAKE_CASE : CLIPImageProcessor , __SCREAMING_SNAKE_CASE : bool = True , ) -> List[str]: super()._init_() lowerCamelCase_ = StableDiffusionPipeline.from_pretrained(__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = StableDiffusionPipeline.from_pretrained(__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = StableDiffusionPipeline.from_pretrained(__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = StableDiffusionPipeline( vae=__SCREAMING_SNAKE_CASE , text_encoder=__SCREAMING_SNAKE_CASE , tokenizer=__SCREAMING_SNAKE_CASE , unet=__SCREAMING_SNAKE_CASE , scheduler=__SCREAMING_SNAKE_CASE , safety_checker=__SCREAMING_SNAKE_CASE , feature_extractor=__SCREAMING_SNAKE_CASE , requires_safety_checker=__SCREAMING_SNAKE_CASE , ) self.register_modules(pipelinea=self.pipea , pipelinea=self.pipea , pipelinea=self.pipea , pipelinea=self.pipea ) @property def UpperCamelCase ( self : List[str] ) -> Dict[str, Any]: return {k: getattr(self , __SCREAMING_SNAKE_CASE ) for k in self.config.keys() if not k.startswith('_' )} def UpperCamelCase ( self : int , __SCREAMING_SNAKE_CASE : Optional[Union[str, int]] = "auto" ) -> Any: if slice_size == "auto": # half the attention head size is usually a good trade-off between # speed and memory lowerCamelCase_ = self.unet.config.attention_head_dim // 2 self.unet.set_attention_slice(__SCREAMING_SNAKE_CASE ) def UpperCamelCase ( self : Any ) -> List[Any]: self.enable_attention_slicing(__SCREAMING_SNAKE_CASE ) @torch.no_grad() def UpperCamelCase ( self : Any , __SCREAMING_SNAKE_CASE : Union[str, List[str]] , __SCREAMING_SNAKE_CASE : int = 512 , __SCREAMING_SNAKE_CASE : int = 512 , __SCREAMING_SNAKE_CASE : int = 50 , __SCREAMING_SNAKE_CASE : float = 7.5 , __SCREAMING_SNAKE_CASE : Optional[Union[str, List[str]]] = None , __SCREAMING_SNAKE_CASE : Optional[int] = 1 , __SCREAMING_SNAKE_CASE : float = 0.0 , __SCREAMING_SNAKE_CASE : Optional[torch.Generator] = None , __SCREAMING_SNAKE_CASE : Optional[torch.FloatTensor] = None , __SCREAMING_SNAKE_CASE : Optional[str] = "pil" , __SCREAMING_SNAKE_CASE : bool = True , __SCREAMING_SNAKE_CASE : Optional[Callable[[int, int, torch.FloatTensor], None]] = None , __SCREAMING_SNAKE_CASE : int = 1 , **__SCREAMING_SNAKE_CASE : int , ) -> Tuple: return self.pipea( prompt=__SCREAMING_SNAKE_CASE , height=__SCREAMING_SNAKE_CASE , width=__SCREAMING_SNAKE_CASE , num_inference_steps=__SCREAMING_SNAKE_CASE , guidance_scale=__SCREAMING_SNAKE_CASE , negative_prompt=__SCREAMING_SNAKE_CASE , num_images_per_prompt=__SCREAMING_SNAKE_CASE , eta=__SCREAMING_SNAKE_CASE , generator=__SCREAMING_SNAKE_CASE , latents=__SCREAMING_SNAKE_CASE , output_type=__SCREAMING_SNAKE_CASE , return_dict=__SCREAMING_SNAKE_CASE , callback=__SCREAMING_SNAKE_CASE , callback_steps=__SCREAMING_SNAKE_CASE , **__SCREAMING_SNAKE_CASE , ) @torch.no_grad() def UpperCamelCase ( self : List[str] , __SCREAMING_SNAKE_CASE : Union[str, List[str]] , __SCREAMING_SNAKE_CASE : int = 512 , __SCREAMING_SNAKE_CASE : int = 512 , __SCREAMING_SNAKE_CASE : int = 50 , __SCREAMING_SNAKE_CASE : float = 7.5 , __SCREAMING_SNAKE_CASE : Optional[Union[str, List[str]]] = None , __SCREAMING_SNAKE_CASE : Optional[int] = 1 , __SCREAMING_SNAKE_CASE : float = 0.0 , __SCREAMING_SNAKE_CASE : Optional[torch.Generator] = None , __SCREAMING_SNAKE_CASE : Optional[torch.FloatTensor] = None , __SCREAMING_SNAKE_CASE : Optional[str] = "pil" , __SCREAMING_SNAKE_CASE : bool = True , __SCREAMING_SNAKE_CASE : Optional[Callable[[int, int, torch.FloatTensor], None]] = None , __SCREAMING_SNAKE_CASE : int = 1 , **__SCREAMING_SNAKE_CASE : List[str] , ) -> Optional[int]: return self.pipea( prompt=__SCREAMING_SNAKE_CASE , height=__SCREAMING_SNAKE_CASE , width=__SCREAMING_SNAKE_CASE , num_inference_steps=__SCREAMING_SNAKE_CASE , guidance_scale=__SCREAMING_SNAKE_CASE , negative_prompt=__SCREAMING_SNAKE_CASE , num_images_per_prompt=__SCREAMING_SNAKE_CASE , eta=__SCREAMING_SNAKE_CASE , generator=__SCREAMING_SNAKE_CASE , latents=__SCREAMING_SNAKE_CASE , output_type=__SCREAMING_SNAKE_CASE , return_dict=__SCREAMING_SNAKE_CASE , callback=__SCREAMING_SNAKE_CASE , callback_steps=__SCREAMING_SNAKE_CASE , **__SCREAMING_SNAKE_CASE , ) @torch.no_grad() def UpperCamelCase ( self : Optional[Any] , __SCREAMING_SNAKE_CASE : Union[str, List[str]] , __SCREAMING_SNAKE_CASE : int = 512 , __SCREAMING_SNAKE_CASE : int = 512 , __SCREAMING_SNAKE_CASE : int = 50 , __SCREAMING_SNAKE_CASE : float = 7.5 , __SCREAMING_SNAKE_CASE : Optional[Union[str, List[str]]] = None , __SCREAMING_SNAKE_CASE : Optional[int] = 1 , __SCREAMING_SNAKE_CASE : float = 0.0 , __SCREAMING_SNAKE_CASE : Optional[torch.Generator] = None , __SCREAMING_SNAKE_CASE : Optional[torch.FloatTensor] = None , __SCREAMING_SNAKE_CASE : Optional[str] = "pil" , __SCREAMING_SNAKE_CASE : bool = True , __SCREAMING_SNAKE_CASE : Optional[Callable[[int, int, torch.FloatTensor], None]] = None , __SCREAMING_SNAKE_CASE : int = 1 , **__SCREAMING_SNAKE_CASE : Optional[int] , ) -> Tuple: return self.pipea( prompt=__SCREAMING_SNAKE_CASE , height=__SCREAMING_SNAKE_CASE , width=__SCREAMING_SNAKE_CASE , num_inference_steps=__SCREAMING_SNAKE_CASE , guidance_scale=__SCREAMING_SNAKE_CASE , negative_prompt=__SCREAMING_SNAKE_CASE , num_images_per_prompt=__SCREAMING_SNAKE_CASE , eta=__SCREAMING_SNAKE_CASE , generator=__SCREAMING_SNAKE_CASE , latents=__SCREAMING_SNAKE_CASE , output_type=__SCREAMING_SNAKE_CASE , return_dict=__SCREAMING_SNAKE_CASE , callback=__SCREAMING_SNAKE_CASE , callback_steps=__SCREAMING_SNAKE_CASE , **__SCREAMING_SNAKE_CASE , ) @torch.no_grad() def UpperCamelCase ( self : Tuple , __SCREAMING_SNAKE_CASE : Union[str, List[str]] , __SCREAMING_SNAKE_CASE : int = 512 , __SCREAMING_SNAKE_CASE : int = 512 , __SCREAMING_SNAKE_CASE : int = 50 , __SCREAMING_SNAKE_CASE : float = 7.5 , __SCREAMING_SNAKE_CASE : Optional[Union[str, List[str]]] = None , __SCREAMING_SNAKE_CASE : Optional[int] = 1 , __SCREAMING_SNAKE_CASE : float = 0.0 , __SCREAMING_SNAKE_CASE : Optional[torch.Generator] = None , __SCREAMING_SNAKE_CASE : Optional[torch.FloatTensor] = None , __SCREAMING_SNAKE_CASE : Optional[str] = "pil" , __SCREAMING_SNAKE_CASE : bool = True , __SCREAMING_SNAKE_CASE : Optional[Callable[[int, int, torch.FloatTensor], None]] = None , __SCREAMING_SNAKE_CASE : int = 1 , **__SCREAMING_SNAKE_CASE : Tuple , ) -> Tuple: return self.pipea( prompt=__SCREAMING_SNAKE_CASE , height=__SCREAMING_SNAKE_CASE , width=__SCREAMING_SNAKE_CASE , num_inference_steps=__SCREAMING_SNAKE_CASE , guidance_scale=__SCREAMING_SNAKE_CASE , negative_prompt=__SCREAMING_SNAKE_CASE , num_images_per_prompt=__SCREAMING_SNAKE_CASE , eta=__SCREAMING_SNAKE_CASE , generator=__SCREAMING_SNAKE_CASE , latents=__SCREAMING_SNAKE_CASE , output_type=__SCREAMING_SNAKE_CASE , return_dict=__SCREAMING_SNAKE_CASE , callback=__SCREAMING_SNAKE_CASE , callback_steps=__SCREAMING_SNAKE_CASE , **__SCREAMING_SNAKE_CASE , ) @torch.no_grad() def UpperCamelCase ( self : Dict , __SCREAMING_SNAKE_CASE : Union[str, List[str]] , __SCREAMING_SNAKE_CASE : int = 512 , __SCREAMING_SNAKE_CASE : int = 512 , __SCREAMING_SNAKE_CASE : int = 50 , __SCREAMING_SNAKE_CASE : float = 7.5 , __SCREAMING_SNAKE_CASE : Optional[Union[str, List[str]]] = None , __SCREAMING_SNAKE_CASE : Optional[int] = 1 , __SCREAMING_SNAKE_CASE : float = 0.0 , __SCREAMING_SNAKE_CASE : Optional[torch.Generator] = None , __SCREAMING_SNAKE_CASE : Optional[torch.FloatTensor] = None , __SCREAMING_SNAKE_CASE : Optional[str] = "pil" , __SCREAMING_SNAKE_CASE : bool = True , __SCREAMING_SNAKE_CASE : Optional[Callable[[int, int, torch.FloatTensor], None]] = None , __SCREAMING_SNAKE_CASE : int = 1 , **__SCREAMING_SNAKE_CASE : int , ) -> str: lowerCamelCase_ = 'cuda' if torch.cuda.is_available() else 'cpu' self.to(__SCREAMING_SNAKE_CASE ) # Checks if the height and width are divisible by 8 or not if height % 8 != 0 or width % 8 != 0: raise ValueError(F'''`height` and `width` must be divisible by 8 but are {height} and {width}.''' ) # Get first result from Stable Diffusion Checkpoint v1.1 lowerCamelCase_ = self.textaimg_sda_a( prompt=__SCREAMING_SNAKE_CASE , height=__SCREAMING_SNAKE_CASE , width=__SCREAMING_SNAKE_CASE , num_inference_steps=__SCREAMING_SNAKE_CASE , guidance_scale=__SCREAMING_SNAKE_CASE , negative_prompt=__SCREAMING_SNAKE_CASE , num_images_per_prompt=__SCREAMING_SNAKE_CASE , eta=__SCREAMING_SNAKE_CASE , generator=__SCREAMING_SNAKE_CASE , latents=__SCREAMING_SNAKE_CASE , output_type=__SCREAMING_SNAKE_CASE , return_dict=__SCREAMING_SNAKE_CASE , callback=__SCREAMING_SNAKE_CASE , callback_steps=__SCREAMING_SNAKE_CASE , **__SCREAMING_SNAKE_CASE , ) # Get first result from Stable Diffusion Checkpoint v1.2 lowerCamelCase_ = self.textaimg_sda_a( prompt=__SCREAMING_SNAKE_CASE , height=__SCREAMING_SNAKE_CASE , width=__SCREAMING_SNAKE_CASE , num_inference_steps=__SCREAMING_SNAKE_CASE , guidance_scale=__SCREAMING_SNAKE_CASE , negative_prompt=__SCREAMING_SNAKE_CASE , num_images_per_prompt=__SCREAMING_SNAKE_CASE , eta=__SCREAMING_SNAKE_CASE , generator=__SCREAMING_SNAKE_CASE , latents=__SCREAMING_SNAKE_CASE , output_type=__SCREAMING_SNAKE_CASE , return_dict=__SCREAMING_SNAKE_CASE , callback=__SCREAMING_SNAKE_CASE , callback_steps=__SCREAMING_SNAKE_CASE , **__SCREAMING_SNAKE_CASE , ) # Get first result from Stable Diffusion Checkpoint v1.3 lowerCamelCase_ = self.textaimg_sda_a( prompt=__SCREAMING_SNAKE_CASE , height=__SCREAMING_SNAKE_CASE , width=__SCREAMING_SNAKE_CASE , num_inference_steps=__SCREAMING_SNAKE_CASE , guidance_scale=__SCREAMING_SNAKE_CASE , negative_prompt=__SCREAMING_SNAKE_CASE , num_images_per_prompt=__SCREAMING_SNAKE_CASE , eta=__SCREAMING_SNAKE_CASE , generator=__SCREAMING_SNAKE_CASE , latents=__SCREAMING_SNAKE_CASE , output_type=__SCREAMING_SNAKE_CASE , return_dict=__SCREAMING_SNAKE_CASE , callback=__SCREAMING_SNAKE_CASE , callback_steps=__SCREAMING_SNAKE_CASE , **__SCREAMING_SNAKE_CASE , ) # Get first result from Stable Diffusion Checkpoint v1.4 lowerCamelCase_ = self.textaimg_sda_a( prompt=__SCREAMING_SNAKE_CASE , height=__SCREAMING_SNAKE_CASE , width=__SCREAMING_SNAKE_CASE , num_inference_steps=__SCREAMING_SNAKE_CASE , guidance_scale=__SCREAMING_SNAKE_CASE , negative_prompt=__SCREAMING_SNAKE_CASE , num_images_per_prompt=__SCREAMING_SNAKE_CASE , eta=__SCREAMING_SNAKE_CASE , generator=__SCREAMING_SNAKE_CASE , latents=__SCREAMING_SNAKE_CASE , output_type=__SCREAMING_SNAKE_CASE , return_dict=__SCREAMING_SNAKE_CASE , callback=__SCREAMING_SNAKE_CASE , callback_steps=__SCREAMING_SNAKE_CASE , **__SCREAMING_SNAKE_CASE , ) # Get all result images into a single list and pass it via StableDiffusionPipelineOutput for final result return StableDiffusionPipelineOutput([resa[0], resa[0], resa[0], resa[0]] )

'''simple docstring''' import argparse import json import os import re import shutil import torch from transformers import BioGptConfig, BioGptForCausalLM from transformers.models.biogpt.tokenization_biogpt import VOCAB_FILES_NAMES from transformers.tokenization_utils_base import TOKENIZER_CONFIG_FILE from transformers.utils import WEIGHTS_NAME, logging logging.set_verbosity_warning() lowerCAmelCase : Union[str, Any] =2 class a_ : def __init__( self : int , *, # begin keyword-only arguments lowercase : List[Any]="<s>" , lowercase : Optional[Any]="<pad>" , lowercase : Dict="</s>" , lowercase : Tuple="<unk>" , lowercase : Optional[int]=None , ): """simple docstring""" lowercase_ , lowercase_ , lowercase_ , lowercase_ :List[Any] = bos, unk, pad, eos lowercase_ :str = [] lowercase_ :Any = [] lowercase_ :Dict = {} lowercase_ :Union[str, Any] = self.add_symbol(lowercase ) lowercase_ :str = self.add_symbol(lowercase ) lowercase_ :Tuple = self.add_symbol(lowercase ) lowercase_ :Any = self.add_symbol(lowercase ) if extra_special_symbols: for s in extra_special_symbols: self.add_symbol(lowercase ) lowercase_ :Tuple = len(self.symbols ) def __eq__( self : Union[str, Any] , lowercase : Any ): """simple docstring""" return self.indices == other.indices def __getitem__( self : Optional[Any] , lowercase : Optional[Any] ): """simple docstring""" if idx < len(self.symbols ): return self.symbols[idx] return self.unk_word def __len__( self : List[str] ): """simple docstring""" return len(self.symbols ) def __contains__( self : List[str] , lowercase : str ): """simple docstring""" return sym in self.indices @classmethod def lowercase__ ( cls : int , lowercase : List[str] ): """simple docstring""" lowercase_ :List[Any] = cls() d.add_from_file(lowercase ) return d def lowercase__ ( self : List[str] , lowercase : List[Any] , lowercase : Dict=1 , lowercase : Dict=False ): """simple docstring""" if word in self.indices and not overwrite: lowercase_ :Union[str, Any] = self.indices[word] lowercase_ :Dict = self.count[idx] + n return idx else: lowercase_ :Optional[Any] = len(self.symbols ) lowercase_ :Optional[int] = idx self.symbols.append(lowercase ) self.count.append(lowercase ) return idx def lowercase__ ( self : str , lowercase : Union[str, Any] ): """simple docstring""" return 0 def lowercase__ ( self : Any , lowercase : List[str] ): """simple docstring""" if isinstance(lowercase , lowercase ): try: with open(lowercase , "r" , encoding="utf-8" ) as fd: self.add_from_file(lowercase ) except FileNotFoundError as fnfe: raise fnfe except UnicodeError: raise Exception("Incorrect encoding detected in {}, please rebuild the dataset".format(lowercase ) ) return lowercase_ :Optional[Any] = f.readlines() lowercase_ :str = self._load_meta(lowercase ) for line in lines[indices_start_line:]: try: lowercase_ , lowercase_ :Dict = line.rstrip().rsplit(" " , 1 ) if field == "#fairseq:overwrite": lowercase_ :Any = True lowercase_ , lowercase_ :Dict = line.rsplit(" " , 1 ) else: lowercase_ :str = False lowercase_ :Optional[Any] = int(lowercase ) lowercase_ :Optional[Any] = line if word in self and not overwrite: raise RuntimeError( "Duplicate word found when loading Dictionary: '{}'. " "Duplicate words can overwrite earlier ones by adding the " "#fairseq:overwrite flag at the end of the corresponding row " "in the dictionary file. If using the Camembert model, please " "download an updated copy of the model file.".format(lowercase ) ) self.add_symbol(lowercase , n=lowercase , overwrite=lowercase ) except ValueError: raise ValueError("Incorrect dictionary format, expected '<token> <cnt> [flags]'" ) def UpperCAmelCase_ ( __lowerCamelCase : List[Any] ): # (1) remove word breaking symbol, (2) add word ending symbol where the word is not broken up, # e.g.: d = {'le@@': 5, 'tt@@': 6, 'er': 7} => {'le': 5, 'tt': 6, 'er</w>': 7} lowercase_ :Any = dict((re.sub(r"@@$" ,"" ,__lowerCamelCase ), v) if k.endswith("@@" ) else (re.sub(r"$" ,"</w>" ,__lowerCamelCase ), v) for k, v in d.items() ) lowercase_ :Dict = "<s> <pad> </s> <unk>".split() # restore the special tokens for k in keep_keys: del da[F'{k}</w>'] lowercase_ :List[Any] = d[k] # restore return da def UpperCAmelCase_ ( __lowerCamelCase : str ,__lowerCamelCase : Tuple ): # prep if not os.path.exists(__lowerCamelCase ): raise ValueError(F'path {biogpt_checkpoint_path} does not exist!' ) os.makedirs(__lowerCamelCase ,exist_ok=__lowerCamelCase ) print(F'Writing results to {pytorch_dump_folder_path}' ) # handle various types of models lowercase_ :List[Any] = os.path.join(__lowerCamelCase ,"checkpoint.pt" ) if not os.path.isfile(__lowerCamelCase ): raise ValueError(F'path to the file {checkpoint_file} does not exist!' ) lowercase_ :Union[str, Any] = torch.load(__lowerCamelCase ,map_location="cpu" ) lowercase_ :Optional[int] = chkpt["cfg"]["model"] # dicts lowercase_ :Tuple = os.path.join(__lowerCamelCase ,"dict.txt" ) if not os.path.isfile(__lowerCamelCase ): raise ValueError(F'path to the file {dict_file} does not exist!' ) lowercase_ :List[Any] = Dictionary.load(__lowerCamelCase ) lowercase_ :Optional[Any] = rewrite_dict_keys(src_dict.indices ) lowercase_ :Dict = len(__lowerCamelCase ) lowercase_ :List[str] = os.path.join(__lowerCamelCase ,VOCAB_FILES_NAMES["vocab_file"] ) print(F'Generating {src_vocab_file} of {src_vocab_size} records' ) with open(__lowerCamelCase ,"w" ,encoding="utf-8" ) as f: f.write(json.dumps(__lowerCamelCase ,ensure_ascii=__lowerCamelCase ,indent=__lowerCamelCase ) ) # merges_file (bpecodes) lowercase_ :int = os.path.join(__lowerCamelCase ,"bpecodes" ) if not os.path.isfile(__lowerCamelCase ): raise ValueError(F'path to the file {bpecodes_file} does not exist!' ) lowercase_ :Optional[int] = os.path.join(__lowerCamelCase ,VOCAB_FILES_NAMES["merges_file"] ) shutil.copyfile(__lowerCamelCase ,__lowerCamelCase ) # model config lowercase_ :List[str] = os.path.join(__lowerCamelCase ,"config.json" ) lowercase_ :int = { "activation_dropout": args["activation_dropout"], "architectures": ["BioGptForCausalLM"], "attention_probs_dropout_prob": args["attention_dropout"], "bos_token_id": 0, "eos_token_id": 2, "hidden_act": args["activation_fn"], "hidden_dropout_prob": args["dropout"], "hidden_size": args["decoder_embed_dim"], "initializer_range": 0.02, "intermediate_size": args["decoder_ffn_embed_dim"], "layer_norm_eps": 1e-12, "layerdrop": args["decoder_layerdrop"], "max_position_embeddings": args["max_target_positions"], "model_type": "biogpt", "num_attention_heads": args["decoder_attention_heads"], "num_hidden_layers": args["decoder_layers"], "pad_token_id": 1, "scale_embedding": not args["no_scale_embedding"], "tie_word_embeddings": args["share_decoder_input_output_embed"], "vocab_size": src_vocab_size, } # good hparam defaults to start with print(F'Generating {biogpt_model_config_file}' ) with open(__lowerCamelCase ,"w" ,encoding="utf-8" ) as f: f.write(json.dumps(__lowerCamelCase ,ensure_ascii=__lowerCamelCase ,indent=__lowerCamelCase ) ) # tokenizer config lowercase_ :List[Any] = os.path.join(__lowerCamelCase ,__lowerCamelCase ) lowercase_ :List[Any] = { "bos_token": "<s>", "eos_token": "</s>", "model_max_length": 10_24, "pad_token": "<pad>", "special_tokens_map_file": None, "tokenizer_class": "BioGptTokenizer", "unk_token": "<unk>", } print(F'Generating {biogpt_tokenizer_config_file}' ) with open(__lowerCamelCase ,"w" ,encoding="utf-8" ) as f: f.write(json.dumps(__lowerCamelCase ,ensure_ascii=__lowerCamelCase ,indent=__lowerCamelCase ) ) # model lowercase_ :List[str] = chkpt["model"] # remove unneeded keys lowercase_ :Optional[int] = [ "decoder.version", ] for k in ignore_keys: model_state_dict.pop(__lowerCamelCase ,__lowerCamelCase ) lowercase_ :Tuple = list(model_state_dict.keys() ) for layer_name in layer_names: if layer_name.endswith("output_projection.weight" ): lowercase_ :str = model_state_dict.pop(__lowerCamelCase ) else: lowercase_ :Optional[int] = model_state_dict.pop(__lowerCamelCase ) lowercase_ :Any = BioGptConfig.from_pretrained(__lowerCamelCase ) lowercase_ :Optional[int] = BioGptForCausalLM(__lowerCamelCase ) # check that it loads ok model_new.load_state_dict(__lowerCamelCase ) # save lowercase_ :Union[str, Any] = os.path.join(__lowerCamelCase ,__lowerCamelCase ) print(F'Generating {pytorch_weights_dump_path}' ) torch.save(__lowerCamelCase ,__lowerCamelCase ) print("Conversion is done!" ) if __name__ == "__main__": lowerCAmelCase : str =argparse.ArgumentParser() # Required parameters parser.add_argument( '''--biogpt_checkpoint_path''', default=None, type=str, required=True, help=( '''Path to the official PyTorch checkpoint file which is expected to reside in the dump dir with dicts,''' ''' bpecodes, etc.''' ), ) parser.add_argument( '''--pytorch_dump_folder_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.''' ) lowerCAmelCase : Any =parser.parse_args() convert_biogpt_checkpoint_to_pytorch(args.biogpt_checkpoint_path, args.pytorch_dump_folder_path)

'''simple docstring''' def UpperCAmelCase_ ( __lowerCamelCase : dict ): lowercase_ :set[int] = set() # To detect a back edge, keep track of vertices currently in the recursion stack lowercase_ :set[int] = set() return any( node not in visited and depth_first_search(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ) for node in graph ) def UpperCAmelCase_ ( __lowerCamelCase : dict ,__lowerCamelCase : int ,__lowerCamelCase : set ,__lowerCamelCase : set ): visited.add(__lowerCamelCase ) rec_stk.add(__lowerCamelCase ) for node in graph[vertex]: if node not in visited: if depth_first_search(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ): return True elif node in rec_stk: return True # The node needs to be removed from recursion stack before function ends rec_stk.remove(__lowerCamelCase ) return False if __name__ == "__main__": from doctest import testmod testmod()

"""simple docstring""" import os import tempfile from functools import partial from unittest import TestCase from unittest.mock import patch import numpy as np import pytest from datasets.arrow_dataset import Dataset from datasets.search import ElasticSearchIndex, FaissIndex, MissingIndex from .utils import require_elasticsearch, require_faiss __UpperCAmelCase = pytest.mark.integration @require_faiss class _SCREAMING_SNAKE_CASE ( A__ ): def __lowerCAmelCase ( self ) -> Any: lowerCAmelCase_ :List[str] = Dataset.from_dict({"""filename""": ["""my_name-train""" + """_""" + str(__UpperCAmelCase ) for x in np.arange(30 ).tolist()]} ) return dset def __lowerCAmelCase ( self ) -> Any: import faiss lowerCAmelCase_ :int = self._create_dummy_dataset() lowerCAmelCase_ :List[str] = dset.map( lambda __A , __A : {"vecs": i * np.ones(5 , dtype=np.floataa )} , with_indices=__UpperCAmelCase , keep_in_memory=__UpperCAmelCase ) lowerCAmelCase_ :List[Any] = dset.add_faiss_index("""vecs""" , batch_size=100 , metric_type=faiss.METRIC_INNER_PRODUCT ) lowerCAmelCase_ , lowerCAmelCase_ :List[Any] = dset.get_nearest_examples("""vecs""" , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples["""filename"""][0] , """my_name-train_29""" ) dset.drop_index("""vecs""" ) def __lowerCAmelCase ( self ) -> Optional[Any]: import faiss lowerCAmelCase_ :Any = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name="""vecs""" , batch_size=100 , metric_type=faiss.METRIC_INNER_PRODUCT , ) lowerCAmelCase_ , lowerCAmelCase_ :Optional[Any] = dset.get_nearest_examples("""vecs""" , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples["""filename"""][0] , """my_name-train_29""" ) def __lowerCAmelCase ( self ) -> Union[str, Any]: import faiss lowerCAmelCase_ :List[str] = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name="""vecs""" , metric_type=faiss.METRIC_INNER_PRODUCT , ) # Setting delete=False and unlinking manually is not pretty... but it is required on Windows to # ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue. # see https://bugs.python.org/issue14243 and # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515 with tempfile.NamedTemporaryFile(delete=__UpperCAmelCase ) as tmp_file: dset.save_faiss_index("""vecs""" , tmp_file.name ) dset.load_faiss_index("""vecs2""" , tmp_file.name ) os.unlink(tmp_file.name ) lowerCAmelCase_ , lowerCAmelCase_ :List[Any] = dset.get_nearest_examples("""vecs2""" , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples["""filename"""][0] , """my_name-train_29""" ) def __lowerCAmelCase ( self ) -> Any: lowerCAmelCase_ :List[str] = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name="""vecs""" ) dset.drop_index("""vecs""" ) self.assertRaises(__UpperCAmelCase , partial(dset.get_nearest_examples , """vecs2""" , np.ones(5 , dtype=np.floataa ) ) ) def __lowerCAmelCase ( self ) -> List[str]: from elasticsearch import Elasticsearch lowerCAmelCase_ :Optional[Any] = self._create_dummy_dataset() with patch("""elasticsearch.Elasticsearch.search""" ) as mocked_search, patch( """elasticsearch.client.IndicesClient.create""" ) as mocked_index_create, patch("""elasticsearch.helpers.streaming_bulk""" ) as mocked_bulk: lowerCAmelCase_ :List[Any] = {"""acknowledged""": True} mocked_bulk.return_value([(True, None)] * 30 ) lowerCAmelCase_ :Tuple = {"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 29}]}} lowerCAmelCase_ :Union[str, Any] = Elasticsearch() dset.add_elasticsearch_index("""filename""" , es_client=__UpperCAmelCase ) lowerCAmelCase_ , lowerCAmelCase_ :Dict = dset.get_nearest_examples("""filename""" , """my_name-train_29""" ) self.assertEqual(examples["""filename"""][0] , """my_name-train_29""" ) @require_faiss class _SCREAMING_SNAKE_CASE ( A__ ): def __lowerCAmelCase ( self ) -> Any: import faiss lowerCAmelCase_ :Tuple = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) # add vectors index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsNotNone(index.faiss_index ) self.assertEqual(index.faiss_index.ntotal , 5 ) index.add_vectors(np.zeros((5, 5) , dtype=np.floataa ) ) self.assertEqual(index.faiss_index.ntotal , 10 ) # single query lowerCAmelCase_ :Union[str, Any] = np.zeros(5 , dtype=np.floataa ) lowerCAmelCase_ :Union[str, Any] = 1 lowerCAmelCase_ , lowerCAmelCase_ :Optional[int] = index.search(__UpperCAmelCase ) self.assertRaises(__UpperCAmelCase , index.search , query.reshape(-1 , 1 ) ) self.assertGreater(scores[0] , 0 ) self.assertEqual(indices[0] , 1 ) # batched queries lowerCAmelCase_ :Optional[Any] = np.eye(5 , dtype=np.floataa )[::-1] lowerCAmelCase_ , lowerCAmelCase_ :List[str] = index.search_batch(__UpperCAmelCase ) self.assertRaises(__UpperCAmelCase , index.search_batch , queries[0] ) lowerCAmelCase_ :Optional[Any] = [scores[0] for scores in total_scores] lowerCAmelCase_ :str = [indices[0] for indices in total_indices] self.assertGreater(np.min(__UpperCAmelCase ) , 0 ) self.assertListEqual([4, 3, 2, 1, 0] , __UpperCAmelCase ) def __lowerCAmelCase ( self ) -> List[Any]: import faiss lowerCAmelCase_ :Optional[Any] = FaissIndex(string_factory="""Flat""" ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexFlat ) lowerCAmelCase_ :Tuple = FaissIndex(string_factory="""LSH""" ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexLSH ) with self.assertRaises(__UpperCAmelCase ): lowerCAmelCase_ :List[str] = FaissIndex(string_factory="""Flat""" , custom_index=faiss.IndexFlat(5 ) ) def __lowerCAmelCase ( self ) -> Optional[Any]: import faiss lowerCAmelCase_ :Optional[int] = faiss.IndexFlat(5 ) lowerCAmelCase_ :List[Any] = FaissIndex(custom_index=__UpperCAmelCase ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexFlat ) def __lowerCAmelCase ( self ) -> Dict: import faiss lowerCAmelCase_ :Optional[Any] = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) # Setting delete=False and unlinking manually is not pretty... but it is required on Windows to # ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue. # see https://bugs.python.org/issue14243 and # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515 with tempfile.NamedTemporaryFile(delete=__UpperCAmelCase ) as tmp_file: index.save(tmp_file.name ) lowerCAmelCase_ :List[Any] = FaissIndex.load(tmp_file.name ) os.unlink(tmp_file.name ) lowerCAmelCase_ :Any = np.zeros(5 , dtype=np.floataa ) lowerCAmelCase_ :Union[str, Any] = 1 lowerCAmelCase_ , lowerCAmelCase_ :Union[str, Any] = index.search(__UpperCAmelCase ) self.assertGreater(scores[0] , 0 ) self.assertEqual(indices[0] , 1 ) @require_faiss def _snake_case ( lowercase__ : Dict ) -> Any: '''simple docstring''' import faiss lowerCAmelCase_ :str = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) lowerCAmelCase_ :Union[str, Any] = """index.faiss""" lowerCAmelCase_ :int = f"""mock://{index_name}""" index.save(lowercase__ , storage_options=mockfs.storage_options ) lowerCAmelCase_ :Any = FaissIndex.load(lowercase__ , storage_options=mockfs.storage_options ) lowerCAmelCase_ :Tuple = np.zeros(5 , dtype=np.floataa ) lowerCAmelCase_ :Union[str, Any] = 1 lowerCAmelCase_ , lowerCAmelCase_ :int = index.search(lowercase__ ) assert scores[0] > 0 assert indices[0] == 1 @require_elasticsearch class _SCREAMING_SNAKE_CASE ( A__ ): def __lowerCAmelCase ( self ) -> List[Any]: from elasticsearch import Elasticsearch with patch("""elasticsearch.Elasticsearch.search""" ) as mocked_search, patch( """elasticsearch.client.IndicesClient.create""" ) as mocked_index_create, patch("""elasticsearch.helpers.streaming_bulk""" ) as mocked_bulk: lowerCAmelCase_ :List[str] = Elasticsearch() lowerCAmelCase_ :Optional[Any] = {"""acknowledged""": True} lowerCAmelCase_ :str = ElasticSearchIndex(es_client=__UpperCAmelCase ) mocked_bulk.return_value([(True, None)] * 3 ) index.add_documents(["""foo""", """bar""", """foobar"""] ) # single query lowerCAmelCase_ :Any = """foo""" lowerCAmelCase_ :Any = {"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 0}]}} lowerCAmelCase_ , lowerCAmelCase_ :int = index.search(__UpperCAmelCase ) self.assertEqual(scores[0] , 1 ) self.assertEqual(indices[0] , 0 ) # single query with timeout lowerCAmelCase_ :int = """foo""" lowerCAmelCase_ :Any = {"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 0}]}} lowerCAmelCase_ , lowerCAmelCase_ :Union[str, Any] = index.search(__UpperCAmelCase , request_timeout=30 ) self.assertEqual(scores[0] , 1 ) self.assertEqual(indices[0] , 0 ) # batched queries lowerCAmelCase_ :Optional[int] = ["""foo""", """bar""", """foobar"""] lowerCAmelCase_ :int = {"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 1}]}} lowerCAmelCase_ , lowerCAmelCase_ :Optional[Any] = index.search_batch(__UpperCAmelCase ) lowerCAmelCase_ :Optional[Any] = [scores[0] for scores in total_scores] lowerCAmelCase_ :int = [indices[0] for indices in total_indices] self.assertGreater(np.min(__UpperCAmelCase ) , 0 ) self.assertListEqual([1, 1, 1] , __UpperCAmelCase ) # batched queries with timeout lowerCAmelCase_ :int = ["""foo""", """bar""", """foobar"""] lowerCAmelCase_ :Any = {"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 1}]}} lowerCAmelCase_ , lowerCAmelCase_ :Optional[int] = index.search_batch(__UpperCAmelCase , request_timeout=30 ) lowerCAmelCase_ :Union[str, Any] = [scores[0] for scores in total_scores] lowerCAmelCase_ :Dict = [indices[0] for indices in total_indices] self.assertGreater(np.min(__UpperCAmelCase ) , 0 ) self.assertListEqual([1, 1, 1] , __UpperCAmelCase )

import argparse import json import logging import os import shutil import sys import tempfile import unittest from unittest import mock import torch from accelerate.utils import write_basic_config from transformers.testing_utils import TestCasePlus, get_gpu_count, run_command, slow, torch_device from transformers.utils import is_apex_available logging.basicConfig(level=logging.DEBUG) UpperCAmelCase__ = logging.getLogger() def _a ( ) -> Optional[int]: a = argparse.ArgumentParser() parser.add_argument('''-f''' ) a = parser.parse_args() return args.f def _a ( a :Any ) -> Tuple: a = {} a = os.path.join(a , '''all_results.json''' ) if os.path.exists(a ): with open(a , '''r''' ) as f: a = json.load(a ) else: raise ValueError(F"""can't find {path}""" ) return results def _a ( ) -> int: a = torch.cuda.is_available() and torch_device == '''cuda''' return is_using_cuda and is_apex_available() UpperCAmelCase__ = logging.StreamHandler(sys.stdout) logger.addHandler(stream_handler) class lowercase_ ( lowercase ): '''simple docstring''' @classmethod def __lowerCAmelCase ( cls : str ) ->Tuple: """simple docstring""" a = tempfile.mkdtemp() a = os.path.join(cls.tmpdir , '''default_config.yml''' ) write_basic_config(save_location=cls.configPath ) a = ['''accelerate''', '''launch''', '''--config_file''', cls.configPath] @classmethod def __lowerCAmelCase ( cls : Optional[int] ) ->Union[str, Any]: """simple docstring""" shutil.rmtree(cls.tmpdir ) @mock.patch.dict(os.environ , {'''WANDB_MODE''': '''offline'''} ) def __lowerCAmelCase ( self : List[Any] ) ->List[str]: """simple docstring""" a = self.get_auto_remove_tmp_dir() a = F""" {self.examples_dir}/pytorch/text-classification/run_glue_no_trainer.py --model_name_or_path distilbert-base-uncased --output_dir {tmp_dir} --train_file ./tests/fixtures/tests_samples/MRPC/train.csv --validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv --per_device_train_batch_size=2 --per_device_eval_batch_size=1 --learning_rate=1e-4 --seed=42 --checkpointing_steps epoch --with_tracking """.split() if is_cuda_and_apex_available(): testargs.append('''--fp16''' ) run_command(self._launch_args + testargs ) a = get_results(__UpperCAmelCase ) self.assertGreaterEqual(result['''eval_accuracy'''] , 0.75 ) self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase , '''epoch_0''' ) ) ) self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase , '''glue_no_trainer''' ) ) ) @mock.patch.dict(os.environ , {'''WANDB_MODE''': '''offline'''} ) def __lowerCAmelCase ( self : Optional[Any] ) ->Any: """simple docstring""" a = self.get_auto_remove_tmp_dir() a = F""" {self.examples_dir}/pytorch/language-modeling/run_clm_no_trainer.py --model_name_or_path distilgpt2 --train_file ./tests/fixtures/sample_text.txt --validation_file ./tests/fixtures/sample_text.txt --block_size 128 --per_device_train_batch_size 5 --per_device_eval_batch_size 5 --num_train_epochs 2 --output_dir {tmp_dir} --checkpointing_steps epoch --with_tracking """.split() if torch.cuda.device_count() > 1: # Skipping because there are not enough batches to train the model + would need a drop_last to work. return run_command(self._launch_args + testargs ) a = get_results(__UpperCAmelCase ) self.assertLess(result['''perplexity'''] , 100 ) self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase , '''epoch_0''' ) ) ) self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase , '''clm_no_trainer''' ) ) ) @mock.patch.dict(os.environ , {'''WANDB_MODE''': '''offline'''} ) def __lowerCAmelCase ( self : Optional[int] ) ->int: """simple docstring""" a = self.get_auto_remove_tmp_dir() a = F""" {self.examples_dir}/pytorch/language-modeling/run_mlm_no_trainer.py --model_name_or_path distilroberta-base --train_file ./tests/fixtures/sample_text.txt --validation_file ./tests/fixtures/sample_text.txt --output_dir {tmp_dir} --num_train_epochs=1 --checkpointing_steps epoch --with_tracking """.split() run_command(self._launch_args + testargs ) a = get_results(__UpperCAmelCase ) self.assertLess(result['''perplexity'''] , 42 ) self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase , '''epoch_0''' ) ) ) self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase , '''mlm_no_trainer''' ) ) ) @mock.patch.dict(os.environ , {'''WANDB_MODE''': '''offline'''} ) def __lowerCAmelCase ( self : Optional[int] ) ->str: """simple docstring""" a = 7 if get_gpu_count() > 1 else 2 a = self.get_auto_remove_tmp_dir() a = F""" {self.examples_dir}/pytorch/token-classification/run_ner_no_trainer.py --model_name_or_path bert-base-uncased --train_file tests/fixtures/tests_samples/conll/sample.json --validation_file tests/fixtures/tests_samples/conll/sample.json --output_dir {tmp_dir} --learning_rate=2e-4 --per_device_train_batch_size=2 --per_device_eval_batch_size=2 --num_train_epochs={epochs} --seed 7 --checkpointing_steps epoch --with_tracking """.split() run_command(self._launch_args + testargs ) a = get_results(__UpperCAmelCase ) self.assertGreaterEqual(result['''eval_accuracy'''] , 0.75 ) self.assertLess(result['''train_loss'''] , 0.5 ) self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase , '''epoch_0''' ) ) ) self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase , '''ner_no_trainer''' ) ) ) @unittest.skip(reason='''Fix me @muellerzr''' ) @mock.patch.dict(os.environ , {'''WANDB_MODE''': '''offline'''} ) def __lowerCAmelCase ( self : Any ) ->int: """simple docstring""" a = self.get_auto_remove_tmp_dir() a = F""" {self.examples_dir}/pytorch/question-answering/run_qa_no_trainer.py --model_name_or_path bert-base-uncased --version_2_with_negative --train_file tests/fixtures/tests_samples/SQUAD/sample.json --validation_file tests/fixtures/tests_samples/SQUAD/sample.json --output_dir {tmp_dir} --seed=42 --max_train_steps=10 --num_warmup_steps=2 --learning_rate=2e-4 --per_device_train_batch_size=2 --per_device_eval_batch_size=1 --checkpointing_steps epoch --with_tracking """.split() run_command(self._launch_args + testargs ) a = get_results(__UpperCAmelCase ) # Because we use --version_2_with_negative the testing script uses SQuAD v2 metrics. self.assertGreaterEqual(result['''eval_f1'''] , 28 ) self.assertGreaterEqual(result['''eval_exact'''] , 28 ) self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase , '''epoch_0''' ) ) ) self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase , '''qa_no_trainer''' ) ) ) @mock.patch.dict(os.environ , {'''WANDB_MODE''': '''offline'''} ) def __lowerCAmelCase ( self : Optional[Any] ) ->Any: """simple docstring""" a = self.get_auto_remove_tmp_dir() a = F""" {self.examples_dir}/pytorch/multiple-choice/run_swag_no_trainer.py --model_name_or_path bert-base-uncased --train_file tests/fixtures/tests_samples/swag/sample.json --validation_file tests/fixtures/tests_samples/swag/sample.json --output_dir {tmp_dir} --max_train_steps=20 --num_warmup_steps=2 --learning_rate=2e-4 --per_device_train_batch_size=2 --per_device_eval_batch_size=1 --with_tracking """.split() run_command(self._launch_args + testargs ) a = get_results(__UpperCAmelCase ) self.assertGreaterEqual(result['''eval_accuracy'''] , 0.8 ) self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase , '''swag_no_trainer''' ) ) ) @slow @mock.patch.dict(os.environ , {'''WANDB_MODE''': '''offline'''} ) def __lowerCAmelCase ( self : Union[str, Any] ) ->Union[str, Any]: """simple docstring""" a = self.get_auto_remove_tmp_dir() a = F""" {self.examples_dir}/pytorch/summarization/run_summarization_no_trainer.py --model_name_or_path t5-small --train_file tests/fixtures/tests_samples/xsum/sample.json --validation_file tests/fixtures/tests_samples/xsum/sample.json --output_dir {tmp_dir} --max_train_steps=50 --num_warmup_steps=8 --learning_rate=2e-4 --per_device_train_batch_size=2 --per_device_eval_batch_size=1 --checkpointing_steps epoch --with_tracking """.split() run_command(self._launch_args + testargs ) a = get_results(__UpperCAmelCase ) self.assertGreaterEqual(result['''eval_rouge1'''] , 10 ) self.assertGreaterEqual(result['''eval_rouge2'''] , 2 ) self.assertGreaterEqual(result['''eval_rougeL'''] , 7 ) self.assertGreaterEqual(result['''eval_rougeLsum'''] , 7 ) self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase , '''epoch_0''' ) ) ) self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase , '''summarization_no_trainer''' ) ) ) @slow @mock.patch.dict(os.environ , {'''WANDB_MODE''': '''offline'''} ) def __lowerCAmelCase ( self : Optional[int] ) ->List[str]: """simple docstring""" a = self.get_auto_remove_tmp_dir() a = F""" {self.examples_dir}/pytorch/translation/run_translation_no_trainer.py --model_name_or_path sshleifer/student_marian_en_ro_6_1 --source_lang en --target_lang ro --train_file tests/fixtures/tests_samples/wmt16/sample.json --validation_file tests/fixtures/tests_samples/wmt16/sample.json --output_dir {tmp_dir} --max_train_steps=50 --num_warmup_steps=8 --num_beams=6 --learning_rate=3e-3 --per_device_train_batch_size=2 --per_device_eval_batch_size=1 --source_lang en_XX --target_lang ro_RO --checkpointing_steps epoch --with_tracking """.split() run_command(self._launch_args + testargs ) a = get_results(__UpperCAmelCase ) self.assertGreaterEqual(result['''eval_bleu'''] , 30 ) self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase , '''epoch_0''' ) ) ) self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase , '''translation_no_trainer''' ) ) ) @slow def __lowerCAmelCase ( self : List[str] ) ->int: """simple docstring""" a = logging.StreamHandler(sys.stdout ) logger.addHandler(__UpperCAmelCase ) a = self.get_auto_remove_tmp_dir() a = F""" {self.examples_dir}/pytorch/semantic-segmentation/run_semantic_segmentation_no_trainer.py --dataset_name huggingface/semantic-segmentation-test-sample --output_dir {tmp_dir} --max_train_steps=10 --num_warmup_steps=2 --learning_rate=2e-4 --per_device_train_batch_size=2 --per_device_eval_batch_size=1 --checkpointing_steps epoch """.split() run_command(self._launch_args + testargs ) a = get_results(__UpperCAmelCase ) self.assertGreaterEqual(result['''eval_overall_accuracy'''] , 0.10 ) @mock.patch.dict(os.environ , {'''WANDB_MODE''': '''offline'''} ) def __lowerCAmelCase ( self : Optional[Any] ) ->Tuple: """simple docstring""" a = self.get_auto_remove_tmp_dir() a = F""" {self.examples_dir}/pytorch/image-classification/run_image_classification_no_trainer.py --model_name_or_path google/vit-base-patch16-224-in21k --dataset_name hf-internal-testing/cats_vs_dogs_sample --learning_rate 1e-4 --per_device_train_batch_size 2 --per_device_eval_batch_size 1 --max_train_steps 2 --train_val_split 0.1 --seed 42 --output_dir {tmp_dir} --with_tracking --checkpointing_steps 1 """.split() if is_cuda_and_apex_available(): testargs.append('''--fp16''' ) run_command(self._launch_args + testargs ) a = get_results(__UpperCAmelCase ) # The base model scores a 25% self.assertGreaterEqual(result['''eval_accuracy'''] , 0.6 ) self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase , '''step_1''' ) ) ) self.assertTrue(os.path.exists(os.path.join(__UpperCAmelCase , '''image_classification_no_trainer''' ) ) )

'''simple docstring''' import copy from ...configuration_utils import PretrainedConfig from ...utils import logging from ..auto.configuration_auto import CONFIG_MAPPING __A =logging.get_logger(__name__) class _snake_case ( a__ ): lowerCAmelCase :Optional[int] = '''upernet''' def __init__( self , _lowerCamelCase=None , _lowerCamelCase=512 , _lowerCamelCase=0.02 , _lowerCamelCase=[1, 2, 3, 6] , _lowerCamelCase=True , _lowerCamelCase=0.4 , _lowerCamelCase=384 , _lowerCamelCase=256 , _lowerCamelCase=1 , _lowerCamelCase=False , _lowerCamelCase=255 , **_lowerCamelCase , ): super().__init__(**_lowerCamelCase) if backbone_config is None: logger.info("""`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.""") UpperCAmelCase__ : List[str] = CONFIG_MAPPING["""resnet"""](out_features=["""stage1""", """stage2""", """stage3""", """stage4"""]) elif isinstance(_lowerCamelCase , _lowerCamelCase): UpperCAmelCase__ : Dict = backbone_config.get("""model_type""") UpperCAmelCase__ : Dict = CONFIG_MAPPING[backbone_model_type] UpperCAmelCase__ : List[Any] = config_class.from_dict(_lowerCamelCase) UpperCAmelCase__ : List[Any] = backbone_config UpperCAmelCase__ : Dict = hidden_size UpperCAmelCase__ : List[Any] = initializer_range UpperCAmelCase__ : Optional[Any] = pool_scales UpperCAmelCase__ : Optional[Any] = use_auxiliary_head UpperCAmelCase__ : Optional[Any] = auxiliary_loss_weight UpperCAmelCase__ : List[Any] = auxiliary_in_channels UpperCAmelCase__ : Optional[Any] = auxiliary_channels UpperCAmelCase__ : Optional[int] = auxiliary_num_convs UpperCAmelCase__ : int = auxiliary_concat_input UpperCAmelCase__ : Optional[int] = loss_ignore_index def snake_case__ ( self): UpperCAmelCase__ : Any = copy.deepcopy(self.__dict__) UpperCAmelCase__ : Tuple = self.backbone_config.to_dict() UpperCAmelCase__ : Dict = self.__class__.model_type return output

'''simple docstring''' from __future__ import annotations import unittest from transformers import is_tf_available from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow if is_tf_available(): import tensorflow as tf from transformers import AutoTokenizer, TFAutoModelForSeqaSeqLM @require_tf @require_sentencepiece @require_tokenizers class _snake_case ( unittest.TestCase ): @slow def snake_case__ ( self): UpperCAmelCase__ : Optional[int] = TFAutoModelForSeqaSeqLM.from_pretrained("""google/mt5-small""") UpperCAmelCase__ : str = AutoTokenizer.from_pretrained("""google/mt5-small""") UpperCAmelCase__ : Optional[Any] = tokenizer("""Hello there""" , return_tensors="""tf""").input_ids UpperCAmelCase__ : Tuple = tokenizer("""Hi I am""" , return_tensors="""tf""").input_ids UpperCAmelCase__ : List[Any] = model(_lowerCamelCase , labels=_lowerCamelCase).loss UpperCAmelCase__ : Tuple = -tf.math.reduce_mean(_lowerCamelCase).numpy() UpperCAmelCase__ : Optional[int] = -21.228168 self.assertTrue(abs(mtf_score - EXPECTED_SCORE) < 2e-4)

'''simple docstring''' import inspect import tempfile import unittest from huggingface_hub import hf_hub_download from transformers import is_torch_available from transformers.testing_utils import is_flaky, require_torch, 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 lowerCamelCase : Tuple = 1E-4 if is_torch_available(): import torch from transformers import AutoformerConfig, AutoformerForPrediction, AutoformerModel from transformers.models.autoformer.modeling_autoformer import AutoformerDecoder, AutoformerEncoder @require_torch class A__ : def __init__( self : int , _a : int , _a : int=16 , _a : Dict=13 , _a : Optional[Any]=7 , _a : List[str]=14 , _a : int=10 , _a : List[Any]=19 , _a : int=5 , _a : Dict=4 , _a : Optional[Any]=True , _a : Tuple=16 , _a : Optional[int]=2 , _a : Any=4 , _a : Optional[int]=4 , _a : str="gelu" , _a : Union[str, Any]=0.1 , _a : Optional[int]=0.1 , _a : str=[1, 2, 3, 4, 5] , _a : Tuple=25 , _a : Union[str, Any]=5 , ) -> Dict: '''simple docstring''' _SCREAMING_SNAKE_CASE =d_model _SCREAMING_SNAKE_CASE =parent _SCREAMING_SNAKE_CASE =batch_size _SCREAMING_SNAKE_CASE =prediction_length _SCREAMING_SNAKE_CASE =context_length _SCREAMING_SNAKE_CASE =cardinality _SCREAMING_SNAKE_CASE =num_time_features _SCREAMING_SNAKE_CASE =lags_sequence _SCREAMING_SNAKE_CASE =embedding_dimension _SCREAMING_SNAKE_CASE =is_training _SCREAMING_SNAKE_CASE =hidden_size _SCREAMING_SNAKE_CASE =num_hidden_layers _SCREAMING_SNAKE_CASE =num_attention_heads _SCREAMING_SNAKE_CASE =intermediate_size _SCREAMING_SNAKE_CASE =hidden_act _SCREAMING_SNAKE_CASE =hidden_dropout_prob _SCREAMING_SNAKE_CASE =attention_probs_dropout_prob _SCREAMING_SNAKE_CASE =context_length _SCREAMING_SNAKE_CASE =prediction_length + label_length _SCREAMING_SNAKE_CASE =label_length _SCREAMING_SNAKE_CASE =moving_average _SCREAMING_SNAKE_CASE =autocorrelation_factor def A ( self : Tuple ) -> Tuple: '''simple docstring''' return AutoformerConfig( d_model=self.d_model , 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 , prediction_length=self.prediction_length , context_length=self.context_length , label_length=self.label_length , lags_sequence=self.lags_sequence , num_time_features=self.num_time_features , num_static_categorical_features=1 , cardinality=[self.cardinality] , embedding_dimension=[self.embedding_dimension] , moving_average=self.moving_average , ) def A ( self : Dict , _a : Tuple ) -> Optional[int]: '''simple docstring''' _SCREAMING_SNAKE_CASE =config.context_length + max(config.lags_sequence ) _SCREAMING_SNAKE_CASE =ids_tensor([self.batch_size, 1] , config.cardinality[0] ) _SCREAMING_SNAKE_CASE =floats_tensor([self.batch_size, _past_length, config.num_time_features] ) _SCREAMING_SNAKE_CASE =floats_tensor([self.batch_size, _past_length] ) _SCREAMING_SNAKE_CASE =floats_tensor([self.batch_size, _past_length] ) > 0.5 # decoder inputs _SCREAMING_SNAKE_CASE =floats_tensor([self.batch_size, config.prediction_length, config.num_time_features] ) _SCREAMING_SNAKE_CASE =floats_tensor([self.batch_size, config.prediction_length] ) _SCREAMING_SNAKE_CASE ={ 'past_values': past_values, 'static_categorical_features': static_categorical_features, 'past_time_features': past_time_features, 'past_observed_mask': past_observed_mask, 'future_time_features': future_time_features, 'future_values': future_values, } return inputs_dict def A ( self : Union[str, Any] ) -> Tuple: '''simple docstring''' _SCREAMING_SNAKE_CASE =self.get_config() _SCREAMING_SNAKE_CASE =self.prepare_autoformer_inputs_dict(_a ) return config, inputs_dict def A ( self : List[Any] ) -> str: '''simple docstring''' _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE =self.prepare_config_and_inputs() return config, inputs_dict def A ( self : int , _a : List[Any] , _a : Union[str, Any] ) -> Optional[Any]: '''simple docstring''' _SCREAMING_SNAKE_CASE =AutoformerModel(config=_a ).to(_a ).eval() _SCREAMING_SNAKE_CASE =model(**_a ) _SCREAMING_SNAKE_CASE =outputs.encoder_last_hidden_state _SCREAMING_SNAKE_CASE =outputs.last_hidden_state with tempfile.TemporaryDirectory() as tmpdirname: _SCREAMING_SNAKE_CASE =model.get_encoder() encoder.save_pretrained(_a ) _SCREAMING_SNAKE_CASE =AutoformerEncoder.from_pretrained(_a ).to(_a ) _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE =model.create_network_inputs(**_a ) _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE =model.decomposition_layer(transformer_inputs[:, : config.context_length, ...] ) _SCREAMING_SNAKE_CASE =torch.cat( (transformer_inputs[:, : config.context_length, ...], feature[:, : config.context_length, ...]) , dim=-1 , ) _SCREAMING_SNAKE_CASE =encoder(inputs_embeds=_a )[0] self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1e-3 ) _SCREAMING_SNAKE_CASE =( torch.mean(transformer_inputs[:, : config.context_length, ...] , dim=1 ) .unsqueeze(1 ) .repeat(1 , config.prediction_length , 1 ) ) _SCREAMING_SNAKE_CASE =torch.zeros( [transformer_inputs.shape[0], config.prediction_length, transformer_inputs.shape[2]] , device=enc_input.device , ) _SCREAMING_SNAKE_CASE =torch.cat( ( torch.cat((seasonal_input[:, -config.label_length :, ...], zeros) , dim=1 ), feature[:, config.context_length - config.label_length :, ...], ) , dim=-1 , ) _SCREAMING_SNAKE_CASE =torch.cat( ( torch.cat((trend_input[:, -config.label_length :, ...], mean) , dim=1 ), feature[:, config.context_length - config.label_length :, ...], ) , dim=-1 , ) with tempfile.TemporaryDirectory() as tmpdirname: _SCREAMING_SNAKE_CASE =model.get_decoder() decoder.save_pretrained(_a ) _SCREAMING_SNAKE_CASE =AutoformerDecoder.from_pretrained(_a ).to(_a ) _SCREAMING_SNAKE_CASE =decoder( trend=_a , inputs_embeds=_a , encoder_hidden_states=_a , )[0] self.parent.assertTrue((last_hidden_state_a - last_hidden_state).abs().max().item() < 1e-3 ) @require_torch class A__ ( A__ , A__ , unittest.TestCase ): A__ = (AutoformerModel, AutoformerForPrediction) if is_torch_available() else () A__ = (AutoformerForPrediction,) if is_torch_available() else () A__ = {'feature-extraction': AutoformerModel} if is_torch_available() else {} A__ = False A__ = False A__ = False A__ = False A__ = False A__ = False def A ( self : str ) -> Optional[int]: '''simple docstring''' _SCREAMING_SNAKE_CASE =AutoformerModelTester(self ) _SCREAMING_SNAKE_CASE =ConfigTester(self , config_class=_a , has_text_modality=_a ) def A ( self : Union[str, Any] ) -> int: '''simple docstring''' self.config_tester.run_common_tests() def A ( self : Optional[int] ) -> Optional[int]: '''simple docstring''' _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE =self.model_tester.prepare_config_and_inputs() for model_class in self.all_model_classes: _SCREAMING_SNAKE_CASE =model_class(_a ) with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(_a ) _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE =model_class.from_pretrained(_a , output_loading_info=_a ) self.assertEqual(info['missing_keys'] , [] ) def A ( self : List[Any] ) -> str: '''simple docstring''' _SCREAMING_SNAKE_CASE =self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.check_encoder_decoder_model_standalone(*_a ) @unittest.skip(reason='Model has no tokens embeddings' ) def A ( self : Optional[Any] ) -> Optional[Any]: '''simple docstring''' pass def A ( self : List[Any] ) -> str: '''simple docstring''' _SCREAMING_SNAKE_CASE =inspect.signature(getattr(_a , 'forward' ) ) # The main input is the name of the argument after `self` _SCREAMING_SNAKE_CASE =list(model_signature.parameters.keys() )[1] self.assertEqual(AutoformerModel.main_input_name , _a ) def A ( self : Dict ) -> int: '''simple docstring''' _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE =self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _SCREAMING_SNAKE_CASE =model_class(_a ) _SCREAMING_SNAKE_CASE =inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _SCREAMING_SNAKE_CASE =[*signature.parameters.keys()] _SCREAMING_SNAKE_CASE =[ 'past_values', 'past_time_features', 'past_observed_mask', 'static_categorical_features', 'static_real_features', 'future_values', 'future_time_features', ] if model.__class__.__name__ in ["AutoformerForPrediction"]: expected_arg_names.append('future_observed_mask' ) expected_arg_names.extend( [ 'decoder_attention_mask', 'head_mask', 'decoder_head_mask', 'cross_attn_head_mask', 'encoder_outputs', 'past_key_values', 'output_hidden_states', 'output_attentions', 'use_cache', 'return_dict', ] ) self.assertListEqual(arg_names[: len(_a )] , _a ) def A ( self : Dict ) -> List[str]: '''simple docstring''' _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE =self.model_tester.prepare_config_and_inputs_for_common() _SCREAMING_SNAKE_CASE =True _SCREAMING_SNAKE_CASE =getattr(self.model_tester , 'seq_length' , _a ) _SCREAMING_SNAKE_CASE =getattr(self.model_tester , 'decoder_seq_length' , _a ) _SCREAMING_SNAKE_CASE =getattr(self.model_tester , 'encoder_seq_length' , _a ) _SCREAMING_SNAKE_CASE =getattr(self.model_tester , 'd_model' , _a ) _SCREAMING_SNAKE_CASE =getattr(self.model_tester , 'num_attention_heads' , _a ) _SCREAMING_SNAKE_CASE =d_model // num_attention_heads for model_class in self.all_model_classes: _SCREAMING_SNAKE_CASE =True _SCREAMING_SNAKE_CASE =False _SCREAMING_SNAKE_CASE =True _SCREAMING_SNAKE_CASE =model_class(_a ) model.to(_a ) model.eval() with torch.no_grad(): _SCREAMING_SNAKE_CASE =model(**self._prepare_for_class(_a , _a ) ) _SCREAMING_SNAKE_CASE =outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions self.assertEqual(len(_a ) , self.model_tester.num_hidden_layers ) # check that output_attentions also work using config del inputs_dict["output_attentions"] _SCREAMING_SNAKE_CASE =True _SCREAMING_SNAKE_CASE =model_class(_a ) model.to(_a ) model.eval() with torch.no_grad(): _SCREAMING_SNAKE_CASE =model(**self._prepare_for_class(_a , _a ) ) _SCREAMING_SNAKE_CASE =outputs.encoder_attentions self.assertEqual(len(_a ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, encoder_seq_length, dim] , ) _SCREAMING_SNAKE_CASE =len(_a ) _SCREAMING_SNAKE_CASE =7 if "last_hidden_state" in outputs: correct_outlen += 1 if "trend" in outputs: correct_outlen += 1 if "past_key_values" in outputs: correct_outlen += 1 # past_key_values have been returned if "loss" in outputs: correct_outlen += 1 if "params" in outputs: correct_outlen += 1 self.assertEqual(_a , _a ) # decoder attentions _SCREAMING_SNAKE_CASE =outputs.decoder_attentions self.assertIsInstance(_a , (list, tuple) ) self.assertEqual(len(_a ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(decoder_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, decoder_seq_length, dim] , ) # cross attentions _SCREAMING_SNAKE_CASE =outputs.cross_attentions self.assertIsInstance(_a , (list, tuple) ) self.assertEqual(len(_a ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(cross_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, decoder_seq_length, dim] , ) # Check attention is always last and order is fine _SCREAMING_SNAKE_CASE =True _SCREAMING_SNAKE_CASE =True _SCREAMING_SNAKE_CASE =model_class(_a ) model.to(_a ) model.eval() with torch.no_grad(): _SCREAMING_SNAKE_CASE =model(**self._prepare_for_class(_a , _a ) ) self.assertEqual(out_len + 2 , len(_a ) ) _SCREAMING_SNAKE_CASE =outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions self.assertEqual(len(_a ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(self_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, encoder_seq_length, dim] , ) @is_flaky() def A ( self : str ) -> Any: '''simple docstring''' super().test_retain_grad_hidden_states_attentions() def _lowerCAmelCase ( _UpperCamelCase : Union[str, Any]="train-batch.pt" ) -> Optional[int]: """simple docstring""" _SCREAMING_SNAKE_CASE =hf_hub_download(repo_id='hf-internal-testing/tourism-monthly-batch' , filename=_UpperCamelCase , repo_type='dataset' ) _SCREAMING_SNAKE_CASE =torch.load(_UpperCamelCase , map_location=_UpperCamelCase ) return batch @require_torch @slow class A__ ( unittest.TestCase ): def A ( self : Union[str, Any] ) -> Optional[Any]: '''simple docstring''' _SCREAMING_SNAKE_CASE =AutoformerModel.from_pretrained('huggingface/autoformer-tourism-monthly' ).to(_a ) _SCREAMING_SNAKE_CASE =prepare_batch() with torch.no_grad(): _SCREAMING_SNAKE_CASE =model( past_values=batch['past_values'] , past_time_features=batch['past_time_features'] , past_observed_mask=batch['past_observed_mask'] , static_categorical_features=batch['static_categorical_features'] , future_values=batch['future_values'] , future_time_features=batch['future_time_features'] , )[0] _SCREAMING_SNAKE_CASE =torch.Size( (64, model.config.prediction_length + model.config.label_length, model.config.feature_size) ) self.assertEqual(output.shape , _a ) _SCREAMING_SNAKE_CASE =torch.tensor( [[0.35_93, -1.33_98, 0.63_30], [0.22_79, 1.53_96, -0.17_92], [0.04_50, 1.32_25, -0.23_35]] , device=_a ) self.assertTrue(torch.allclose(output[0, :3, :3] , _a , atol=_a ) ) def A ( self : int ) -> str: '''simple docstring''' _SCREAMING_SNAKE_CASE =AutoformerForPrediction.from_pretrained('huggingface/autoformer-tourism-monthly' ).to(_a ) _SCREAMING_SNAKE_CASE =prepare_batch('val-batch.pt' ) with torch.no_grad(): _SCREAMING_SNAKE_CASE =model( past_values=batch['past_values'] , past_time_features=batch['past_time_features'] , past_observed_mask=batch['past_observed_mask'] , static_categorical_features=batch['static_categorical_features'] , ).encoder_last_hidden_state _SCREAMING_SNAKE_CASE =torch.Size((64, model.config.context_length, model.config.d_model) ) self.assertEqual(output.shape , _a ) _SCREAMING_SNAKE_CASE =torch.tensor( [[-0.07_34, -0.90_36, 0.83_58], [4.71_86, 2.41_13, 1.95_81], [1.79_53, 2.35_58, 1.29_70]] , device=_a ) self.assertTrue(torch.allclose(output[0, :3, :3] , _a , atol=_a ) ) def A ( self : Any ) -> str: '''simple docstring''' _SCREAMING_SNAKE_CASE =AutoformerForPrediction.from_pretrained('huggingface/autoformer-tourism-monthly' ).to(_a ) _SCREAMING_SNAKE_CASE =prepare_batch('val-batch.pt' ) with torch.no_grad(): _SCREAMING_SNAKE_CASE =model.generate( static_categorical_features=batch['static_categorical_features'] , past_time_features=batch['past_time_features'] , past_values=batch['past_values'] , future_time_features=batch['future_time_features'] , past_observed_mask=batch['past_observed_mask'] , ) _SCREAMING_SNAKE_CASE =torch.Size((64, model.config.num_parallel_samples, model.config.prediction_length) ) self.assertEqual(outputs.sequences.shape , _a ) _SCREAMING_SNAKE_CASE =torch.tensor([31_30.67_63, 40_56.52_93, 70_53.07_86] , device=_a ) _SCREAMING_SNAKE_CASE =outputs.sequences.mean(dim=1 ) self.assertTrue(torch.allclose(mean_prediction[0, -3:] , _a , rtol=1e-1 ) )

'''simple docstring''' import unittest import numpy as np import torch from diffusers import VersatileDiffusionImageVariationPipeline from diffusers.utils.testing_utils import load_image, require_torch_gpu, slow, torch_device lowerCamelCase : Optional[int] = False class A__ ( unittest.TestCase ): pass @slow @require_torch_gpu class A__ ( unittest.TestCase ): def A ( self : Tuple ) -> Dict: '''simple docstring''' _SCREAMING_SNAKE_CASE =VersatileDiffusionImageVariationPipeline.from_pretrained('shi-labs/versatile-diffusion' ) pipe.to(_a ) pipe.set_progress_bar_config(disable=_a ) _SCREAMING_SNAKE_CASE =load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg' ) _SCREAMING_SNAKE_CASE =torch.manual_seed(0 ) _SCREAMING_SNAKE_CASE =pipe( image=_a , generator=_a , guidance_scale=7.5 , num_inference_steps=50 , output_type='numpy' , ).images _SCREAMING_SNAKE_CASE =image[0, 253:256, 253:256, -1] assert image.shape == (1, 512, 512, 3) _SCREAMING_SNAKE_CASE =np.array([0.04_41, 0.04_69, 0.05_07, 0.05_75, 0.06_32, 0.06_50, 0.08_65, 0.09_09, 0.09_45] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2

'''simple docstring''' import math import tensorflow as tf from packaging import version def a_ ( _UpperCAmelCase : Optional[Any] ) -> Union[str, Any]: __snake_case : Optional[Any] = tf.convert_to_tensor(_UpperCAmelCase ) __snake_case : str = 0.5 * (1.0 + tf.math.erf(x / tf.cast(tf.sqrt(2.0 ) ,x.dtype ) )) return x * cdf def a_ ( _UpperCAmelCase : List[Any] ) -> Tuple: __snake_case : Dict = tf.convert_to_tensor(_UpperCAmelCase ) __snake_case : List[Any] = tf.cast(math.pi ,x.dtype ) __snake_case : List[str] = tf.cast(0.0_4_4_7_1_5 ,x.dtype ) __snake_case : Optional[Any] = 0.5 * (1.0 + tf.tanh(tf.sqrt(2.0 / pi ) * (x + coeff * tf.pow(_UpperCAmelCase ,3 )) )) return x * cdf def a_ ( _UpperCAmelCase : Optional[int] ) -> Optional[Any]: __snake_case : Any = tf.convert_to_tensor(_UpperCAmelCase ) return x * tf.tanh(tf.math.softplus(_UpperCAmelCase ) ) def a_ ( _UpperCAmelCase : str ) -> Dict: __snake_case : Optional[Any] = tf.convert_to_tensor(_UpperCAmelCase ) __snake_case : List[Any] = tf.cast(0.0_4_4_7_1_5 ,x.dtype ) __snake_case : List[str] = tf.cast(0.7_9_7_8_8_4_5_6_0_8 ,x.dtype ) return 0.5 * x * (1.0 + tf.tanh(x * coeffa * (1.0 + coeffa * x * x) )) def a_ ( _UpperCAmelCase : Dict ) -> Optional[int]: __snake_case : List[Any] = tf.convert_to_tensor(_UpperCAmelCase ) __snake_case : str = tf.cast(1.7_0_2 ,x.dtype ) return x * tf.math.sigmoid(coeff * x ) def a_ ( _UpperCAmelCase : List[Any] ) -> Tuple: return tf.clip_by_value(_gelu(_UpperCAmelCase ) ,-10 ,10 ) def a_ ( _UpperCAmelCase : List[str] ,_UpperCAmelCase : str=-1 ) -> Dict: __snake_case : Dict = tf.split(_UpperCAmelCase ,2 ,axis=_UpperCAmelCase ) return a * tf.math.sigmoid(_UpperCAmelCase ) if version.parse(tf.version.VERSION) >= version.parse('''2.4'''): def a_ ( _UpperCAmelCase : int ) -> Dict: return tf.keras.activations.gelu(_UpperCAmelCase ,approximate=_UpperCAmelCase ) A__ : List[Any] = tf.keras.activations.gelu A__ : str = approximate_gelu_wrap else: A__ : List[str] = _gelu A__ : List[str] = _gelu_new A__ : str = { '''gelu''': gelu, '''gelu_10''': gelu_aa, '''gelu_fast''': gelu_fast, '''gelu_new''': gelu_new, '''glu''': glu, '''mish''': mish, '''quick_gelu''': quick_gelu, '''relu''': tf.keras.activations.relu, '''sigmoid''': tf.keras.activations.sigmoid, '''silu''': tf.keras.activations.swish, '''swish''': tf.keras.activations.swish, '''tanh''': tf.keras.activations.tanh, } def a_ ( _UpperCAmelCase : int ) -> int: if activation_string in ACTaFN: return ACTaFN[activation_string] else: raise KeyError(f'''function {activation_string} not found in ACT2FN mapping {list(ACTaFN.keys() )}''' )

'''simple docstring''' import argparse import json import logging import os import shutil import sys import tempfile import unittest from unittest import mock import torch from accelerate.utils import write_basic_config from transformers.testing_utils import TestCasePlus, get_gpu_count, run_command, slow, torch_device from transformers.utils import is_apex_available logging.basicConfig(level=logging.DEBUG) A__ : Dict = logging.getLogger() def a_ ( ) -> Tuple: __snake_case : List[Any] = argparse.ArgumentParser() parser.add_argument('-f' ) __snake_case : Any = parser.parse_args() return args.f def a_ ( _UpperCAmelCase : Optional[int] ) -> List[Any]: __snake_case : Tuple = {} __snake_case : Union[str, Any] = os.path.join(_UpperCAmelCase ,'all_results.json' ) if os.path.exists(_UpperCAmelCase ): with open(_UpperCAmelCase ,'r' ) as f: __snake_case : List[str] = json.load(_UpperCAmelCase ) else: raise ValueError(f'''can\'t find {path}''' ) return results def a_ ( ) -> Union[str, Any]: __snake_case : Union[str, Any] = torch.cuda.is_available() and torch_device == 'cuda' return is_using_cuda and is_apex_available() A__ : str = logging.StreamHandler(sys.stdout) logger.addHandler(stream_handler) class snake_case__ ( SCREAMING_SNAKE_CASE_ ): @classmethod def A_ ( cls : Any ) -> List[str]: '''simple docstring''' # Write Accelerate config, will pick up on CPU, GPU, and multi-GPU __snake_case : Optional[int] = tempfile.mkdtemp() __snake_case : Dict = os.path.join(cls.tmpdir , 'default_config.yml' ) write_basic_config(save_location=cls.configPath ) __snake_case : List[Any] = ['accelerate', 'launch', '--config_file', cls.configPath] @classmethod def A_ ( cls : List[str] ) -> List[str]: '''simple docstring''' shutil.rmtree(cls.tmpdir ) @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def A_ ( self : Any ) -> Optional[Any]: '''simple docstring''' __snake_case : List[Any] = self.get_auto_remove_tmp_dir() __snake_case : Dict = f''' {self.examples_dir}/pytorch/text-classification/run_glue_no_trainer.py --model_name_or_path distilbert-base-uncased --output_dir {tmp_dir} --train_file ./tests/fixtures/tests_samples/MRPC/train.csv --validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv --per_device_train_batch_size=2 --per_device_eval_batch_size=1 --learning_rate=1e-4 --seed=42 --checkpointing_steps epoch --with_tracking '''.split() if is_cuda_and_apex_available(): testargs.append('--fp16' ) run_command(self._launch_args + testargs ) __snake_case : List[Any] = get_results(__a ) self.assertGreaterEqual(result['eval_accuracy'] , 0.7_5 ) self.assertTrue(os.path.exists(os.path.join(__a , 'epoch_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(__a , 'glue_no_trainer' ) ) ) @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def A_ ( self : List[Any] ) -> Union[str, Any]: '''simple docstring''' __snake_case : Tuple = self.get_auto_remove_tmp_dir() __snake_case : str = f''' {self.examples_dir}/pytorch/language-modeling/run_clm_no_trainer.py --model_name_or_path distilgpt2 --train_file ./tests/fixtures/sample_text.txt --validation_file ./tests/fixtures/sample_text.txt --block_size 128 --per_device_train_batch_size 5 --per_device_eval_batch_size 5 --num_train_epochs 2 --output_dir {tmp_dir} --checkpointing_steps epoch --with_tracking '''.split() if torch.cuda.device_count() > 1: # Skipping because there are not enough batches to train the model + would need a drop_last to work. return run_command(self._launch_args + testargs ) __snake_case : str = get_results(__a ) self.assertLess(result['perplexity'] , 100 ) self.assertTrue(os.path.exists(os.path.join(__a , 'epoch_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(__a , 'clm_no_trainer' ) ) ) @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def A_ ( self : str ) -> List[str]: '''simple docstring''' __snake_case : int = self.get_auto_remove_tmp_dir() __snake_case : List[str] = f''' {self.examples_dir}/pytorch/language-modeling/run_mlm_no_trainer.py --model_name_or_path distilroberta-base --train_file ./tests/fixtures/sample_text.txt --validation_file ./tests/fixtures/sample_text.txt --output_dir {tmp_dir} --num_train_epochs=1 --checkpointing_steps epoch --with_tracking '''.split() run_command(self._launch_args + testargs ) __snake_case : List[str] = get_results(__a ) self.assertLess(result['perplexity'] , 42 ) self.assertTrue(os.path.exists(os.path.join(__a , 'epoch_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(__a , 'mlm_no_trainer' ) ) ) @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def A_ ( self : Optional[int] ) -> Optional[int]: '''simple docstring''' # with so little data distributed training needs more epochs to get the score on par with 0/1 gpu __snake_case : Any = 7 if get_gpu_count() > 1 else 2 __snake_case : Any = self.get_auto_remove_tmp_dir() __snake_case : int = f''' {self.examples_dir}/pytorch/token-classification/run_ner_no_trainer.py --model_name_or_path bert-base-uncased --train_file tests/fixtures/tests_samples/conll/sample.json --validation_file tests/fixtures/tests_samples/conll/sample.json --output_dir {tmp_dir} --learning_rate=2e-4 --per_device_train_batch_size=2 --per_device_eval_batch_size=2 --num_train_epochs={epochs} --seed 7 --checkpointing_steps epoch --with_tracking '''.split() run_command(self._launch_args + testargs ) __snake_case : Dict = get_results(__a ) self.assertGreaterEqual(result['eval_accuracy'] , 0.7_5 ) self.assertLess(result['train_loss'] , 0.5 ) self.assertTrue(os.path.exists(os.path.join(__a , 'epoch_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(__a , 'ner_no_trainer' ) ) ) @unittest.skip(reason='Fix me @muellerzr' ) @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def A_ ( self : Any ) -> List[Any]: '''simple docstring''' __snake_case : Any = self.get_auto_remove_tmp_dir() __snake_case : Tuple = f''' {self.examples_dir}/pytorch/question-answering/run_qa_no_trainer.py --model_name_or_path bert-base-uncased --version_2_with_negative --train_file tests/fixtures/tests_samples/SQUAD/sample.json --validation_file tests/fixtures/tests_samples/SQUAD/sample.json --output_dir {tmp_dir} --seed=42 --max_train_steps=10 --num_warmup_steps=2 --learning_rate=2e-4 --per_device_train_batch_size=2 --per_device_eval_batch_size=1 --checkpointing_steps epoch --with_tracking '''.split() run_command(self._launch_args + testargs ) __snake_case : str = get_results(__a ) # Because we use --version_2_with_negative the testing script uses SQuAD v2 metrics. self.assertGreaterEqual(result['eval_f1'] , 28 ) self.assertGreaterEqual(result['eval_exact'] , 28 ) self.assertTrue(os.path.exists(os.path.join(__a , 'epoch_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(__a , 'qa_no_trainer' ) ) ) @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def A_ ( self : Dict ) -> List[Any]: '''simple docstring''' __snake_case : str = self.get_auto_remove_tmp_dir() __snake_case : Any = f''' {self.examples_dir}/pytorch/multiple-choice/run_swag_no_trainer.py --model_name_or_path bert-base-uncased --train_file tests/fixtures/tests_samples/swag/sample.json --validation_file tests/fixtures/tests_samples/swag/sample.json --output_dir {tmp_dir} --max_train_steps=20 --num_warmup_steps=2 --learning_rate=2e-4 --per_device_train_batch_size=2 --per_device_eval_batch_size=1 --with_tracking '''.split() run_command(self._launch_args + testargs ) __snake_case : str = get_results(__a ) self.assertGreaterEqual(result['eval_accuracy'] , 0.8 ) self.assertTrue(os.path.exists(os.path.join(__a , 'swag_no_trainer' ) ) ) @slow @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def A_ ( self : Any ) -> Union[str, Any]: '''simple docstring''' __snake_case : Tuple = self.get_auto_remove_tmp_dir() __snake_case : List[str] = f''' {self.examples_dir}/pytorch/summarization/run_summarization_no_trainer.py --model_name_or_path t5-small --train_file tests/fixtures/tests_samples/xsum/sample.json --validation_file tests/fixtures/tests_samples/xsum/sample.json --output_dir {tmp_dir} --max_train_steps=50 --num_warmup_steps=8 --learning_rate=2e-4 --per_device_train_batch_size=2 --per_device_eval_batch_size=1 --checkpointing_steps epoch --with_tracking '''.split() run_command(self._launch_args + testargs ) __snake_case : int = get_results(__a ) self.assertGreaterEqual(result['eval_rouge1'] , 10 ) self.assertGreaterEqual(result['eval_rouge2'] , 2 ) self.assertGreaterEqual(result['eval_rougeL'] , 7 ) self.assertGreaterEqual(result['eval_rougeLsum'] , 7 ) self.assertTrue(os.path.exists(os.path.join(__a , 'epoch_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(__a , 'summarization_no_trainer' ) ) ) @slow @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def A_ ( self : Union[str, Any] ) -> int: '''simple docstring''' __snake_case : Tuple = self.get_auto_remove_tmp_dir() __snake_case : str = f''' {self.examples_dir}/pytorch/translation/run_translation_no_trainer.py --model_name_or_path sshleifer/student_marian_en_ro_6_1 --source_lang en --target_lang ro --train_file tests/fixtures/tests_samples/wmt16/sample.json --validation_file tests/fixtures/tests_samples/wmt16/sample.json --output_dir {tmp_dir} --max_train_steps=50 --num_warmup_steps=8 --num_beams=6 --learning_rate=3e-3 --per_device_train_batch_size=2 --per_device_eval_batch_size=1 --source_lang en_XX --target_lang ro_RO --checkpointing_steps epoch --with_tracking '''.split() run_command(self._launch_args + testargs ) __snake_case : Dict = get_results(__a ) self.assertGreaterEqual(result['eval_bleu'] , 30 ) self.assertTrue(os.path.exists(os.path.join(__a , 'epoch_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(__a , 'translation_no_trainer' ) ) ) @slow def A_ ( self : Optional[Any] ) -> Optional[Any]: '''simple docstring''' __snake_case : Union[str, Any] = logging.StreamHandler(sys.stdout ) logger.addHandler(__a ) __snake_case : List[str] = self.get_auto_remove_tmp_dir() __snake_case : int = f''' {self.examples_dir}/pytorch/semantic-segmentation/run_semantic_segmentation_no_trainer.py --dataset_name huggingface/semantic-segmentation-test-sample --output_dir {tmp_dir} --max_train_steps=10 --num_warmup_steps=2 --learning_rate=2e-4 --per_device_train_batch_size=2 --per_device_eval_batch_size=1 --checkpointing_steps epoch '''.split() run_command(self._launch_args + testargs ) __snake_case : List[str] = get_results(__a ) self.assertGreaterEqual(result['eval_overall_accuracy'] , 0.1_0 ) @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def A_ ( self : Tuple ) -> Any: '''simple docstring''' __snake_case : Dict = self.get_auto_remove_tmp_dir() __snake_case : Dict = f''' {self.examples_dir}/pytorch/image-classification/run_image_classification_no_trainer.py --model_name_or_path google/vit-base-patch16-224-in21k --dataset_name hf-internal-testing/cats_vs_dogs_sample --learning_rate 1e-4 --per_device_train_batch_size 2 --per_device_eval_batch_size 1 --max_train_steps 2 --train_val_split 0.1 --seed 42 --output_dir {tmp_dir} --with_tracking --checkpointing_steps 1 '''.split() if is_cuda_and_apex_available(): testargs.append('--fp16' ) run_command(self._launch_args + testargs ) __snake_case : Optional[int] = get_results(__a ) # The base model scores a 25% self.assertGreaterEqual(result['eval_accuracy'] , 0.6 ) self.assertTrue(os.path.exists(os.path.join(__a , 'step_1' ) ) ) self.assertTrue(os.path.exists(os.path.join(__a , 'image_classification_no_trainer' ) ) )

"""simple docstring""" import inspect import unittest from transformers import DecisionTransformerConfig, is_torch_available from transformers.testing_utils import require_torch, slow, torch_device from ...generation.test_utils import GenerationTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import DecisionTransformerModel from transformers.models.decision_transformer.modeling_decision_transformer import ( DECISION_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, ) class _UpperCAmelCase: def __init__( self , __a , __a=13 , __a=7 , __a=6 , __a=17 , __a=23 , __a=11 , __a=True , ) -> Optional[int]: '''simple docstring''' _UpperCamelCase = parent _UpperCamelCase = batch_size _UpperCamelCase = seq_length _UpperCamelCase = act_dim _UpperCamelCase = state_dim _UpperCamelCase = hidden_size _UpperCamelCase = max_length _UpperCamelCase = is_training def UpperCAmelCase ( self) -> Optional[int]: '''simple docstring''' _UpperCamelCase = floats_tensor((self.batch_size, self.seq_length, self.state_dim)) _UpperCamelCase = floats_tensor((self.batch_size, self.seq_length, self.act_dim)) _UpperCamelCase = floats_tensor((self.batch_size, self.seq_length, 1)) _UpperCamelCase = floats_tensor((self.batch_size, self.seq_length, 1)) _UpperCamelCase = ids_tensor((self.batch_size, self.seq_length) , vocab_size=10_00) _UpperCamelCase = random_attention_mask((self.batch_size, self.seq_length)) _UpperCamelCase = self.get_config() return ( config, states, actions, rewards, returns_to_go, timesteps, attention_mask, ) def UpperCAmelCase ( self) -> List[str]: '''simple docstring''' return DecisionTransformerConfig( batch_size=self.batch_size , seq_length=self.seq_length , act_dim=self.act_dim , state_dim=self.state_dim , hidden_size=self.hidden_size , max_length=self.max_length , ) def UpperCAmelCase ( self , __a , __a , __a , __a , __a , __a , __a , ) -> Optional[Any]: '''simple docstring''' _UpperCamelCase = DecisionTransformerModel(config=__a) model.to(__a) model.eval() _UpperCamelCase = model(__a , __a , __a , __a , __a , __a) self.parent.assertEqual(result.state_preds.shape , states.shape) self.parent.assertEqual(result.action_preds.shape , actions.shape) self.parent.assertEqual(result.return_preds.shape , returns_to_go.shape) self.parent.assertEqual( result.last_hidden_state.shape , (self.batch_size, self.seq_length * 3, self.hidden_size)) # seq length *3 as there are 3 modelities: states, returns and actions def UpperCAmelCase ( self) -> Union[str, Any]: '''simple docstring''' _UpperCamelCase = self.prepare_config_and_inputs() ( ( _UpperCamelCase ) , ( _UpperCamelCase ) , ( _UpperCamelCase ) , ( _UpperCamelCase ) , ( _UpperCamelCase ) , ( _UpperCamelCase ) , ( _UpperCamelCase ) , ) = config_and_inputs _UpperCamelCase = { '''states''': states, '''actions''': actions, '''rewards''': rewards, '''returns_to_go''': returns_to_go, '''timesteps''': timesteps, '''attention_mask''': attention_mask, } return config, inputs_dict @require_torch class _UpperCAmelCase( lowerCamelCase , lowerCamelCase , lowerCamelCase , unittest.TestCase ): lowercase__ = (DecisionTransformerModel,) if is_torch_available() else () lowercase__ = () lowercase__ = {'feature-extraction': DecisionTransformerModel} if is_torch_available() else {} # Ignoring of a failing test from GenerationTesterMixin, as the model does not use inputs_ids lowercase__ = False # Ignoring of a failing tests from ModelTesterMixin, as the model does not implement these features lowercase__ = False lowercase__ = False lowercase__ = False lowercase__ = False lowercase__ = False lowercase__ = False lowercase__ = False lowercase__ = False lowercase__ = False def UpperCAmelCase ( self) -> List[Any]: '''simple docstring''' _UpperCamelCase = DecisionTransformerModelTester(self) _UpperCamelCase = ConfigTester(self , config_class=__a , hidden_size=37) def UpperCAmelCase ( self) -> Dict: '''simple docstring''' self.config_tester.run_common_tests() def UpperCAmelCase ( self) -> Any: '''simple docstring''' _UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*__a) @slow def UpperCAmelCase ( self) -> Optional[int]: '''simple docstring''' for model_name in DECISION_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _UpperCamelCase = DecisionTransformerModel.from_pretrained(__a) self.assertIsNotNone(__a) def UpperCAmelCase ( self) -> Dict: '''simple docstring''' _UpperCamelCase , _UpperCamelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCamelCase = model_class(__a) _UpperCamelCase = inspect.signature(model.forward) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCamelCase = [*signature.parameters.keys()] _UpperCamelCase = [ '''states''', '''actions''', '''rewards''', '''returns_to_go''', '''timesteps''', '''attention_mask''', ] self.assertListEqual(arg_names[: len(__a)] , __a) @require_torch class _UpperCAmelCase( unittest.TestCase ): @slow def UpperCAmelCase ( self) -> Optional[Any]: '''simple docstring''' _UpperCamelCase = 2 # number of steps of autoregressive prediction we will perform _UpperCamelCase = 10 # defined by the RL environment, may be normalized _UpperCamelCase = DecisionTransformerModel.from_pretrained('''edbeeching/decision-transformer-gym-hopper-expert''') _UpperCamelCase = model.to(__a) _UpperCamelCase = model.config torch.manual_seed(0) _UpperCamelCase = torch.randn(1 , 1 , config.state_dim).to(device=__a , dtype=torch.floataa) # env.reset() _UpperCamelCase = torch.tensor( [[0.24_2793, -0.2869_3074, 0.874_2613], [0.6781_5274, -0.0810_1085, -0.1295_2147]] , device=__a) _UpperCamelCase = torch.tensor(__a , device=__a , dtype=torch.floataa).reshape(1 , 1 , 1) _UpperCamelCase = state _UpperCamelCase = torch.zeros(1 , 0 , config.act_dim , device=__a , dtype=torch.floataa) _UpperCamelCase = torch.zeros(1 , 0 , device=__a , dtype=torch.floataa) _UpperCamelCase = torch.tensor(0 , device=__a , dtype=torch.long).reshape(1 , 1) for step in range(__a): _UpperCamelCase = torch.cat([actions, torch.zeros(1 , 1 , config.act_dim , device=__a)] , dim=1) _UpperCamelCase = torch.cat([rewards, torch.zeros(1 , 1 , device=__a)] , dim=1) _UpperCamelCase = torch.ones(1 , states.shape[1]).to(dtype=torch.long , device=states.device) with torch.no_grad(): _UpperCamelCase , _UpperCamelCase , _UpperCamelCase = model( states=__a , actions=__a , rewards=__a , returns_to_go=__a , timesteps=__a , attention_mask=__a , return_dict=__a , ) self.assertEqual(action_pred.shape , actions.shape) self.assertTrue(torch.allclose(action_pred[0, -1] , expected_outputs[step] , atol=1e-4)) _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase = ( # env.step(action) torch.randn(1 , 1 , config.state_dim).to(device=__a , dtype=torch.floataa), 1.0, False, {}, ) _UpperCamelCase = action_pred[0, -1] _UpperCamelCase = torch.cat([states, state] , dim=1) _UpperCamelCase = returns_to_go[0, -1] - reward _UpperCamelCase = torch.cat([returns_to_go, pred_return.reshape(1 , 1 , 1)] , dim=1) _UpperCamelCase = torch.cat( [timesteps, torch.ones((1, 1) , device=__a , dtype=torch.long) * (step + 1)] , dim=1)

"""simple docstring""" import numpy as np from cva import COLOR_BGR2GRAY, CV_8UC3, cvtColor, filteraD, imread, imshow, waitKey def lowerCamelCase__ ( __snake_case, __snake_case, __snake_case, __snake_case, __snake_case, __snake_case ) -> np.ndarray: """simple docstring""" if (ksize % 2) == 0: _UpperCamelCase = ksize + 1 _UpperCamelCase = np.zeros((ksize, ksize), dtype=np.floataa ) # each value for y in range(__snake_case ): for x in range(__snake_case ): # distance from center _UpperCamelCase = x - ksize // 2 _UpperCamelCase = y - ksize // 2 # degree to radiant _UpperCamelCase = theta / 1_80 * np.pi _UpperCamelCase = np.cos(_theta ) _UpperCamelCase = np.sin(_theta ) # get kernel x _UpperCamelCase = cos_theta * px + sin_theta * py # get kernel y _UpperCamelCase = -sin_theta * px + cos_theta * py # fill kernel _UpperCamelCase = np.exp( -(_x**2 + gamma**2 * _y**2) / (2 * sigma**2) ) * np.cos(2 * np.pi * _x / lambd + psi ) return gabor if __name__ == "__main__": import doctest doctest.testmod() # read original image _a = imread("""../image_data/lena.jpg""") # turn image in gray scale value _a = cvtColor(img, COLOR_BGR2GRAY) # Apply multiple Kernel to detect edges _a = np.zeros(gray.shape[:2]) for theta in [0, 30, 60, 90, 120, 150]: _a = gabor_filter_kernel(10, 8, theta, 10, 0, 0) out += filteraD(gray, CV_8UC3, kernel_aa) _a = out / out.max() * 255 _a = out.astype(np.uinta) imshow("""Original""", gray) imshow("""Gabor filter with 20x20 mask and 6 directions""", out) waitKey(0)

import itertools import random import unittest import numpy as np from transformers import is_speech_available from transformers.testing_utils import require_torch, require_torchaudio from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin if is_speech_available(): from transformers import SpeechaTextFeatureExtractor __SCREAMING_SNAKE_CASE : List[str] = random.Random() def snake_case (__lowercase , __lowercase=1.0 , __lowercase=None , __lowercase=None ) -> List[Any]: '''simple docstring''' if rng is None: _snake_case : List[str] = global_rng _snake_case : Dict = [] for batch_idx in range(shape[0] ): values.append([] ) for _ in range(shape[1] ): values[-1].append(rng.random() * scale ) return values @require_torch @require_torchaudio class lowercase_ ( unittest.TestCase ): def __init__( self , lowercase_ , lowercase_=7 , lowercase_=400 , lowercase_=2_000 , lowercase_=24 , lowercase_=24 , lowercase_=0.0 , lowercase_=16_000 , lowercase_=True , lowercase_=True , ): _snake_case : Optional[int] = parent _snake_case : Tuple = batch_size _snake_case : int = min_seq_length _snake_case : str = max_seq_length _snake_case : str = (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1) _snake_case : List[Any] = feature_size _snake_case : List[str] = num_mel_bins _snake_case : Optional[Any] = padding_value _snake_case : str = sampling_rate _snake_case : Dict = return_attention_mask _snake_case : Dict = do_normalize def UpperCamelCase ( self ): return { "feature_size": self.feature_size, "num_mel_bins": self.num_mel_bins, "padding_value": self.padding_value, "sampling_rate": self.sampling_rate, "return_attention_mask": self.return_attention_mask, "do_normalize": self.do_normalize, } def UpperCamelCase ( self , lowercase_=False , lowercase_=False ): def _flatten(lowercase_ ): return list(itertools.chain(*lowercase_ ) ) if equal_length: _snake_case : List[str] = [floats_list((self.max_seq_length, self.feature_size) ) for _ in range(self.batch_size )] else: # make sure that inputs increase in size _snake_case : Dict = [ floats_list((x, self.feature_size) ) for x in range(self.min_seq_length , self.max_seq_length , self.seq_length_diff ) ] if numpify: _snake_case : Optional[Any] = [np.asarray(lowercase_ ) for x in speech_inputs] return speech_inputs @require_torch @require_torchaudio class lowercase_ ( __snake_case , unittest.TestCase ): _lowerCamelCase = SpeechaTextFeatureExtractor if is_speech_available() else None def UpperCamelCase ( self ): _snake_case : List[Any] = SpeechaTextFeatureExtractionTester(self ) def UpperCamelCase ( self , lowercase_ ): self.assertTrue(np.all(np.mean(lowercase_ , axis=0 ) < 1e-3 ) ) self.assertTrue(np.all(np.abs(np.var(lowercase_ , axis=0 ) - 1 ) < 1e-3 ) ) def UpperCamelCase ( self ): # Tests that all call wrap to encode_plus and batch_encode_plus _snake_case : Tuple = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() ) # create three inputs of length 800, 1000, and 1200 _snake_case : List[Any] = [floats_list((1, x) )[0] for x in range(800 , 1_400 , 200 )] _snake_case : Union[str, Any] = [np.asarray(lowercase_ ) for speech_input in speech_inputs] # Test feature size _snake_case : str = feature_extractor(lowercase_ , padding=lowercase_ , return_tensors="np" ).input_features self.assertTrue(input_features.ndim == 3 ) self.assertTrue(input_features.shape[-1] == feature_extractor.feature_size ) # Test not batched input _snake_case : Tuple = feature_extractor(speech_inputs[0] , return_tensors="np" ).input_features _snake_case : Dict = feature_extractor(np_speech_inputs[0] , return_tensors="np" ).input_features self.assertTrue(np.allclose(lowercase_ , lowercase_ , atol=1e-3 ) ) # Test batched _snake_case : Optional[Any] = feature_extractor(lowercase_ , return_tensors="np" ).input_features _snake_case : List[str] = feature_extractor(lowercase_ , return_tensors="np" ).input_features for enc_seq_a, enc_seq_a in zip(lowercase_ , lowercase_ ): self.assertTrue(np.allclose(lowercase_ , lowercase_ , atol=1e-3 ) ) # Test 2-D numpy arrays are batched. _snake_case : Union[str, Any] = [floats_list((1, x) )[0] for x in (800, 800, 800)] _snake_case : Optional[Any] = np.asarray(lowercase_ ) _snake_case : List[str] = feature_extractor(lowercase_ , return_tensors="np" ).input_features _snake_case : int = feature_extractor(lowercase_ , return_tensors="np" ).input_features for enc_seq_a, enc_seq_a in zip(lowercase_ , lowercase_ ): self.assertTrue(np.allclose(lowercase_ , lowercase_ , atol=1e-3 ) ) def UpperCamelCase ( self ): _snake_case : int = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() ) _snake_case : List[Any] = [floats_list((1, x) )[0] for x in range(800 , 1_400 , 200 )] _snake_case : str = ["longest", "max_length", "do_not_pad"] _snake_case : str = [None, 16, None] for max_length, padding in zip(lowercase_ , lowercase_ ): _snake_case : Dict = feature_extractor( lowercase_ , padding=lowercase_ , max_length=lowercase_ , return_attention_mask=lowercase_ ) _snake_case : Dict = inputs.input_features _snake_case : Any = inputs.attention_mask _snake_case : Dict = [np.sum(lowercase_ ) for x in attention_mask] self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]] ) self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]] ) self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]] ) def UpperCamelCase ( self ): _snake_case : Optional[int] = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() ) _snake_case : Optional[Any] = [floats_list((1, x) )[0] for x in range(800 , 1_400 , 200 )] _snake_case : Optional[Any] = ["longest", "max_length", "do_not_pad"] _snake_case : List[str] = [None, 16, None] for max_length, padding in zip(lowercase_ , lowercase_ ): _snake_case : Optional[Any] = feature_extractor( lowercase_ , max_length=lowercase_ , padding=lowercase_ , return_tensors="np" , return_attention_mask=lowercase_ ) _snake_case : int = inputs.input_features _snake_case : Union[str, Any] = inputs.attention_mask _snake_case : List[str] = [np.sum(lowercase_ ) for x in attention_mask] self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]] ) self.assertTrue(input_features[0][fbank_feat_lengths[0] :].sum() < 1e-6 ) self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]] ) self.assertTrue(input_features[0][fbank_feat_lengths[1] :].sum() < 1e-6 ) self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]] ) def UpperCamelCase ( self ): _snake_case : List[Any] = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() ) _snake_case : Any = [floats_list((1, x) )[0] for x in range(800 , 1_400 , 200 )] _snake_case : List[Any] = feature_extractor( lowercase_ , padding="max_length" , max_length=4 , truncation=lowercase_ , return_tensors="np" , return_attention_mask=lowercase_ , ) _snake_case : Any = inputs.input_features _snake_case : List[str] = inputs.attention_mask _snake_case : Union[str, Any] = np.sum(attention_mask == 1 , axis=1 ) self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]] ) self._check_zero_mean_unit_variance(input_features[1] ) self._check_zero_mean_unit_variance(input_features[2] ) def UpperCamelCase ( self ): _snake_case : Union[str, Any] = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() ) _snake_case : Optional[int] = [floats_list((1, x) )[0] for x in range(800 , 1_400 , 200 )] _snake_case : Any = feature_extractor( lowercase_ , padding="longest" , max_length=4 , truncation=lowercase_ , return_tensors="np" , return_attention_mask=lowercase_ , ) _snake_case : List[str] = inputs.input_features _snake_case : List[str] = inputs.attention_mask _snake_case : Tuple = np.sum(attention_mask == 1 , axis=1 ) self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]] ) self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]] ) self._check_zero_mean_unit_variance(input_features[2] ) # make sure that if max_length < longest -> then pad to max_length self.assertEqual(input_features.shape , (3, 4, 24) ) _snake_case : Any = [floats_list((1, x) )[0] for x in range(800 , 1_400 , 200 )] _snake_case : Optional[Any] = feature_extractor( lowercase_ , padding="longest" , max_length=16 , truncation=lowercase_ , return_tensors="np" , return_attention_mask=lowercase_ , ) _snake_case : Union[str, Any] = inputs.input_features _snake_case : int = inputs.attention_mask _snake_case : int = np.sum(attention_mask == 1 , axis=1 ) self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]] ) self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]] ) self._check_zero_mean_unit_variance(input_features[2] ) # make sure that if max_length < longest -> then pad to max_length self.assertEqual(input_features.shape , (3, 6, 24) ) def UpperCamelCase ( self ): import torch _snake_case : Any = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() ) _snake_case : Any = np.random.rand(100 , 32 ).astype(np.floataa ) _snake_case : str = np_speech_inputs.tolist() for inputs in [py_speech_inputs, np_speech_inputs]: _snake_case : Union[str, Any] = feature_extractor.pad([{"input_features": inputs}] , return_tensors="np" ) self.assertTrue(np_processed.input_features.dtype == np.floataa ) _snake_case : List[Any] = feature_extractor.pad([{"input_features": inputs}] , return_tensors="pt" ) self.assertTrue(pt_processed.input_features.dtype == torch.floataa ) def UpperCamelCase ( self , lowercase_ ): from datasets import load_dataset _snake_case : Tuple = load_dataset("hf-internal-testing/librispeech_asr_dummy" , "clean" , split="validation" ) # automatic decoding with librispeech _snake_case : Tuple = ds.sort("id" ).select(range(lowercase_ ) )[:num_samples]["audio"] return [x["array"] for x in speech_samples] def UpperCamelCase ( self ): # fmt: off _snake_case : Any = np.array([ -1.5_745, -1.7_713, -1.7_020, -1.6_069, -1.2_250, -1.1_105, -0.9_072, -0.8_241, -1.2_310, -0.8_098, -0.3_320, -0.4_101, -0.7_985, -0.4_996, -0.8_213, -0.9_128, -1.0_420, -1.1_286, -1.0_440, -0.7_999, -0.8_405, -1.2_275, -1.5_443, -1.4_625, ] ) # fmt: on _snake_case : Any = self._load_datasamples(1 ) _snake_case : Optional[Any] = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() ) _snake_case : Tuple = feature_extractor(lowercase_ , return_tensors="pt" ).input_features self.assertEquals(input_features.shape , (1, 584, 24) ) self.assertTrue(np.allclose(input_features[0, 0, :30] , lowercase_ , atol=1e-4 ) )

from __future__ import annotations import string from itertools import cycle, product from pathlib import Path __SCREAMING_SNAKE_CASE : str = ( string.ascii_letters + string.digits + string.punctuation + string.whitespace ) __SCREAMING_SNAKE_CASE : list[int] = [ord(letter) for letter in string.ascii_lowercase] __SCREAMING_SNAKE_CASE : set[int] = {ord(char) for char in VALID_CHARS} __SCREAMING_SNAKE_CASE : list[str] = ["the", "be", "to", "of", "and", "in", "that", "have"] def snake_case (__lowercase , __lowercase ) -> str | None: '''simple docstring''' _snake_case : str = "" _snake_case : int _snake_case : int _snake_case : int for keychar, cipherchar in zip(cycle(__lowercase ) , __lowercase ): _snake_case : str = cipherchar ^ keychar if decodedchar not in VALID_INTS: return None decoded += chr(__lowercase ) return decoded def snake_case (__lowercase ) -> list[str]: '''simple docstring''' _snake_case : list[str] = [] for key in product(__lowercase , repeat=3 ): _snake_case : Union[str, Any] = try_key(__lowercase , __lowercase ) if encoded is not None: possibles.append(__lowercase ) return possibles def snake_case (__lowercase , __lowercase ) -> list[str]: '''simple docstring''' return [possible for possible in possibles if common_word in possible.lower()] def snake_case (__lowercase = "p059_cipher.txt" ) -> int: '''simple docstring''' _snake_case : list[int] _snake_case : list[str] _snake_case : str _snake_case : str _snake_case : str = Path(__lowercase ).parent.joinpath(__lowercase ).read_text(encoding="utf-8" ) _snake_case : Dict = [int(__lowercase ) for number in data.strip().split("," )] _snake_case : Tuple = filter_valid_chars(__lowercase ) for common_word in COMMON_WORDS: _snake_case : Optional[int] = filter_common_word(__lowercase , __lowercase ) if len(__lowercase ) == 1: break _snake_case : int = possibles[0] return sum(ord(__lowercase ) for char in decoded_text ) if __name__ == "__main__": print(F'''{solution() = }''')

"""simple docstring""" import warnings from ...utils import is_sklearn_available, requires_backends if is_sklearn_available(): from scipy.stats import pearsonr, spearmanr from sklearn.metrics import fa_score, matthews_corrcoef a__ : Any = ( '''This metric will be removed from the library soon, metrics should be handled with the 🤗 Evaluate ''' '''library. You can have a look at this example script for pointers: ''' '''https://github.com/huggingface/transformers/blob/main/examples/pytorch/text-classification/run_glue.py''' ) def UpperCAmelCase__ (lowerCAmelCase_ , lowerCAmelCase_ ): '''simple docstring''' warnings.warn(lowerCAmelCase_ , lowerCAmelCase_ ) requires_backends(lowerCAmelCase_ , "sklearn" ) return (preds == labels).mean() def UpperCAmelCase__ (lowerCAmelCase_ , lowerCAmelCase_ ): '''simple docstring''' warnings.warn(lowerCAmelCase_ , lowerCAmelCase_ ) requires_backends(lowerCAmelCase_ , "sklearn" ) __SCREAMING_SNAKE_CASE = simple_accuracy(lowerCAmelCase_ , lowerCAmelCase_ ) __SCREAMING_SNAKE_CASE = fa_score(y_true=lowerCAmelCase_ , y_pred=lowerCAmelCase_ ) return { "acc": acc, "f1": fa, "acc_and_f1": (acc + fa) / 2, } def UpperCAmelCase__ (lowerCAmelCase_ , lowerCAmelCase_ ): '''simple docstring''' warnings.warn(lowerCAmelCase_ , lowerCAmelCase_ ) requires_backends(lowerCAmelCase_ , "sklearn" ) __SCREAMING_SNAKE_CASE = pearsonr(lowerCAmelCase_ , lowerCAmelCase_ )[0] __SCREAMING_SNAKE_CASE = spearmanr(lowerCAmelCase_ , lowerCAmelCase_ )[0] return { "pearson": pearson_corr, "spearmanr": spearman_corr, "corr": (pearson_corr + spearman_corr) / 2, } def UpperCAmelCase__ (lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ ): '''simple docstring''' warnings.warn(lowerCAmelCase_ , lowerCAmelCase_ ) requires_backends(lowerCAmelCase_ , "sklearn" ) assert len(lowerCAmelCase_ ) == len(lowerCAmelCase_ ), f"""Predictions and labels have mismatched lengths {len(lowerCAmelCase_ )} and {len(lowerCAmelCase_ )}""" if task_name == "cola": return {"mcc": matthews_corrcoef(lowerCAmelCase_ , lowerCAmelCase_ )} elif task_name == "sst-2": return {"acc": simple_accuracy(lowerCAmelCase_ , lowerCAmelCase_ )} elif task_name == "mrpc": return acc_and_fa(lowerCAmelCase_ , lowerCAmelCase_ ) elif task_name == "sts-b": return pearson_and_spearman(lowerCAmelCase_ , lowerCAmelCase_ ) elif task_name == "qqp": return acc_and_fa(lowerCAmelCase_ , lowerCAmelCase_ ) elif task_name == "mnli": return {"mnli/acc": simple_accuracy(lowerCAmelCase_ , lowerCAmelCase_ )} elif task_name == "mnli-mm": return {"mnli-mm/acc": simple_accuracy(lowerCAmelCase_ , lowerCAmelCase_ )} elif task_name == "qnli": return {"acc": simple_accuracy(lowerCAmelCase_ , lowerCAmelCase_ )} elif task_name == "rte": return {"acc": simple_accuracy(lowerCAmelCase_ , lowerCAmelCase_ )} elif task_name == "wnli": return {"acc": simple_accuracy(lowerCAmelCase_ , lowerCAmelCase_ )} elif task_name == "hans": return {"acc": simple_accuracy(lowerCAmelCase_ , lowerCAmelCase_ )} else: raise KeyError(lowerCAmelCase_ ) def UpperCAmelCase__ (lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ ): '''simple docstring''' warnings.warn(lowerCAmelCase_ , lowerCAmelCase_ ) requires_backends(lowerCAmelCase_ , "sklearn" ) if len(lowerCAmelCase_ ) != len(lowerCAmelCase_ ): raise ValueError(f"""Predictions and labels have mismatched lengths {len(lowerCAmelCase_ )} and {len(lowerCAmelCase_ )}""" ) if task_name == "xnli": return {"acc": simple_accuracy(lowerCAmelCase_ , lowerCAmelCase_ )} else: raise KeyError(lowerCAmelCase_ )

"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_tokenizers_available, is_torch_available, ) a__ : str = { '''configuration_roformer''': ['''ROFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''RoFormerConfig''', '''RoFormerOnnxConfig'''], '''tokenization_roformer''': ['''RoFormerTokenizer'''], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a__ : int = ['''RoFormerTokenizerFast'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a__ : int = [ '''ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''', '''RoFormerForCausalLM''', '''RoFormerForMaskedLM''', '''RoFormerForMultipleChoice''', '''RoFormerForQuestionAnswering''', '''RoFormerForSequenceClassification''', '''RoFormerForTokenClassification''', '''RoFormerLayer''', '''RoFormerModel''', '''RoFormerPreTrainedModel''', '''load_tf_weights_in_roformer''', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a__ : List[Any] = [ '''TF_ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''', '''TFRoFormerForCausalLM''', '''TFRoFormerForMaskedLM''', '''TFRoFormerForMultipleChoice''', '''TFRoFormerForQuestionAnswering''', '''TFRoFormerForSequenceClassification''', '''TFRoFormerForTokenClassification''', '''TFRoFormerLayer''', '''TFRoFormerModel''', '''TFRoFormerPreTrainedModel''', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a__ : Tuple = [ '''FLAX_ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''', '''FlaxRoFormerForMaskedLM''', '''FlaxRoFormerForMultipleChoice''', '''FlaxRoFormerForQuestionAnswering''', '''FlaxRoFormerForSequenceClassification''', '''FlaxRoFormerForTokenClassification''', '''FlaxRoFormerModel''', '''FlaxRoFormerPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_roformer import ROFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, RoFormerConfig, RoFormerOnnxConfig from .tokenization_roformer import RoFormerTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_roformer_fast import RoFormerTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_roformer import ( ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, RoFormerForCausalLM, RoFormerForMaskedLM, RoFormerForMultipleChoice, RoFormerForQuestionAnswering, RoFormerForSequenceClassification, RoFormerForTokenClassification, RoFormerLayer, RoFormerModel, RoFormerPreTrainedModel, load_tf_weights_in_roformer, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_roformer import ( TF_ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, TFRoFormerForCausalLM, TFRoFormerForMaskedLM, TFRoFormerForMultipleChoice, TFRoFormerForQuestionAnswering, TFRoFormerForSequenceClassification, TFRoFormerForTokenClassification, TFRoFormerLayer, TFRoFormerModel, TFRoFormerPreTrainedModel, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_roformer import ( FLAX_ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, FlaxRoFormerForMaskedLM, FlaxRoFormerForMultipleChoice, FlaxRoFormerForQuestionAnswering, FlaxRoFormerForSequenceClassification, FlaxRoFormerForTokenClassification, FlaxRoFormerModel, FlaxRoFormerPreTrainedModel, ) else: import sys a__ : int = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

def A ( lowercase ) -> None: '''simple docstring''' UpperCamelCase = generate_pascal_triangle(lowercase ) for row_idx in range(lowercase ): # Print left spaces for _ in range(num_rows - row_idx - 1 ): print(end=' ' ) # Print row values for col_idx in range(row_idx + 1 ): if col_idx != row_idx: print(triangle[row_idx][col_idx] , end=' ' ) else: print(triangle[row_idx][col_idx] , end='' ) print() def A ( lowercase ) -> list[list[int]]: '''simple docstring''' if not isinstance(lowercase , lowercase ): raise TypeError('The input value of \'num_rows\' should be \'int\'' ) if num_rows == 0: return [] elif num_rows < 0: raise ValueError( 'The input value of \'num_rows\' should be greater than or equal to 0' ) UpperCamelCase = [] for current_row_idx in range(lowercase ): UpperCamelCase = populate_current_row(lowercase , lowercase ) triangle.append(lowercase ) return triangle def A ( lowercase , lowercase ) -> list[int]: '''simple docstring''' UpperCamelCase = [-1] * (current_row_idx + 1) # first and last elements of current row are equal to 1 UpperCamelCase , UpperCamelCase = 1, 1 for current_col_idx in range(1 , lowercase ): calculate_current_element( lowercase , lowercase , lowercase , lowercase ) return current_row def A ( lowercase , lowercase , lowercase , lowercase , ) -> None: '''simple docstring''' UpperCamelCase = triangle[current_row_idx - 1][current_col_idx - 1] UpperCamelCase = triangle[current_row_idx - 1][current_col_idx] UpperCamelCase = above_to_left_elt + above_to_right_elt def A ( lowercase ) -> list[list[int]]: '''simple docstring''' if not isinstance(lowercase , lowercase ): raise TypeError('The input value of \'num_rows\' should be \'int\'' ) if num_rows == 0: return [] elif num_rows < 0: raise ValueError( 'The input value of \'num_rows\' should be greater than or equal to 0' ) UpperCamelCase = [[1]] for row_index in range(1 , lowercase ): UpperCamelCase = [0] + result[-1] + [0] UpperCamelCase = row_index + 1 # Calculate the number of distinct elements in a row UpperCamelCase = sum(divmod(lowercase , 2 ) ) UpperCamelCase = [ temp_row[i - 1] + temp_row[i] for i in range(1 , distinct_elements + 1 ) ] UpperCamelCase = row_first_half[: (row_index + 1) // 2] row_second_half.reverse() UpperCamelCase = row_first_half + row_second_half result.append(lowercase ) return result def A ( ) -> None: '''simple docstring''' from collections.abc import Callable from timeit import timeit def benchmark_a_function(lowercase , lowercase ) -> None: UpperCamelCase = f'''{func.__name__}({value})''' UpperCamelCase = timeit(f'''__main__.{call}''' , setup='import __main__' ) # print(f"{call:38} = {func(value)} -- {timing:.4f} seconds") print(f'''{call:38} -- {timing:.4f} seconds''' ) for value in range(15 ): # (1, 7, 14): for func in (generate_pascal_triangle, generate_pascal_triangle_optimized): benchmark_a_function(lowercase , lowercase ) print() if __name__ == "__main__": import doctest doctest.testmod() benchmark()

from __future__ import annotations def A ( lowercase , lowercase ) -> tuple[int, int]: '''simple docstring''' if b == 0: return (1, 0) ((UpperCamelCase) , (UpperCamelCase)) = extended_euclid(lowercase , a % b ) UpperCamelCase = a // b return (y, x - k * y) def A ( lowercase , lowercase , lowercase , lowercase ) -> int: '''simple docstring''' ((UpperCamelCase) , (UpperCamelCase)) = extended_euclid(lowercase , lowercase ) UpperCamelCase = na * na UpperCamelCase = ra * x * na + ra * y * na return (n % m + m) % m def A ( lowercase , lowercase ) -> int: '''simple docstring''' ((UpperCamelCase) , (UpperCamelCase)) = extended_euclid(lowercase , lowercase ) if b < 0: UpperCamelCase = (b % n + n) % n return b def A ( lowercase , lowercase , lowercase , lowercase ) -> int: '''simple docstring''' UpperCamelCase , UpperCamelCase = invert_modulo(lowercase , lowercase ), invert_modulo(lowercase , lowercase ) UpperCamelCase = na * na UpperCamelCase = ra * x * na + ra * y * na return (n % m + m) % m if __name__ == "__main__": from doctest import testmod testmod(name="chinese_remainder_theorem", verbose=True) testmod(name="chinese_remainder_theorem2", verbose=True) testmod(name="invert_modulo", verbose=True) testmod(name="extended_euclid", verbose=True)

from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCAmelCase__ = logging.get_logger(__name__) UpperCAmelCase__ = { "vinvino02/glpn-kitti": "https://huggingface.co/vinvino02/glpn-kitti/resolve/main/config.json", # See all GLPN models at https://huggingface.co/models?filter=glpn } class lowercase_ ( lowercase ): '''simple docstring''' __snake_case = '''glpn''' def __init__( self : List[str] , __UpperCAmelCase : str=3 , __UpperCAmelCase : str=4 , __UpperCAmelCase : Dict=[2, 2, 2, 2] , __UpperCAmelCase : Optional[Any]=[8, 4, 2, 1] , __UpperCAmelCase : Dict=[32, 64, 160, 256] , __UpperCAmelCase : Any=[7, 3, 3, 3] , __UpperCAmelCase : Union[str, Any]=[4, 2, 2, 2] , __UpperCAmelCase : Optional[Any]=[1, 2, 5, 8] , __UpperCAmelCase : int=[4, 4, 4, 4] , __UpperCAmelCase : str="gelu" , __UpperCAmelCase : int=0.0 , __UpperCAmelCase : Optional[int]=0.0 , __UpperCAmelCase : List[Any]=0.02 , __UpperCAmelCase : Union[str, Any]=0.1 , __UpperCAmelCase : List[Any]=1e-6 , __UpperCAmelCase : Dict=64 , __UpperCAmelCase : Union[str, Any]=10 , __UpperCAmelCase : List[Any]=-1 , **__UpperCAmelCase : Optional[int] , ) ->Dict: """simple docstring""" super().__init__(**__UpperCAmelCase ) a = num_channels a = num_encoder_blocks a = depths a = sr_ratios a = hidden_sizes a = patch_sizes a = strides a = mlp_ratios a = num_attention_heads a = hidden_act a = hidden_dropout_prob a = attention_probs_dropout_prob a = initializer_range a = drop_path_rate a = layer_norm_eps a = decoder_hidden_size a = max_depth a = head_in_index

from __future__ import annotations import time import numpy as np UpperCAmelCase__ = [8, 5, 9, 7] UpperCAmelCase__ = [ [2, 0, 1, 1], [0, 1, 2, 1], [4, 0, 0, 3], [0, 2, 1, 0], [1, 0, 3, 0], ] UpperCAmelCase__ = [ [3, 2, 1, 4], [0, 2, 5, 2], [5, 1, 0, 5], [1, 5, 3, 0], [3, 0, 3, 3], ] class lowercase_ : '''simple docstring''' def __init__( self : Optional[int] , __UpperCAmelCase : list[int] , __UpperCAmelCase : list[list[int]] , __UpperCAmelCase : list[list[int]] , ) ->None: """simple docstring""" a = claim_vector a = allocated_resources_table a = maximum_claim_table def __lowerCAmelCase ( self : Any ) ->list[int]: """simple docstring""" return [ sum(p_item[i] for p_item in self.__allocated_resources_table ) for i in range(len(self.__allocated_resources_table[0] ) ) ] def __lowerCAmelCase ( self : Optional[int] ) ->list[int]: """simple docstring""" return np.array(self.__claim_vector ) - np.array( self.__processes_resource_summation() ) def __lowerCAmelCase ( self : Union[str, Any] ) ->list[list[int]]: """simple docstring""" return [ list(np.array(self.__maximum_claim_table[i] ) - np.array(__UpperCAmelCase ) ) for i, allocated_resource in enumerate(self.__allocated_resources_table ) ] def __lowerCAmelCase ( self : Tuple ) ->dict[int, list[int]]: """simple docstring""" return {self.__need().index(__UpperCAmelCase ): i for i in self.__need()} def __lowerCAmelCase ( self : Optional[Any] , **__UpperCAmelCase : Any ) ->None: """simple docstring""" a = self.__need() a = self.__allocated_resources_table a = self.__available_resources() a = self.__need_index_manager() for kw, val in kwargs.items(): if kw and val is True: self.__pretty_data() print('''_''' * 50 + '''\n''' ) while need_list: a = False for each_need in need_list: a = True for index, need in enumerate(__UpperCAmelCase ): if need > available_resources[index]: a = False break if execution: a = True # get the original index of the process from ind_ctrl db for original_need_index, need_clone in need_index_manager.items(): if each_need == need_clone: a = original_need_index print(F"""Process {process_number + 1} is executing.""" ) # remove the process run from stack need_list.remove(__UpperCAmelCase ) # update available/freed resources stack a = np.array(__UpperCAmelCase ) + np.array( alloc_resources_table[process_number] ) print( '''Updated available resource stack for processes: ''' + ''' '''.join([str(__UpperCAmelCase ) for x in available_resources] ) ) break if safe: print('''The process is in a safe state.\n''' ) else: print('''System in unsafe state. Aborting...\n''' ) break def __lowerCAmelCase ( self : List[Any] ) ->Dict: """simple docstring""" print(''' ''' * 9 + '''Allocated Resource Table''' ) for item in self.__allocated_resources_table: print( F"""P{self.__allocated_resources_table.index(__UpperCAmelCase ) + 1}""" + ''' '''.join(F"""{it:>8}""" for it in item ) + '''\n''' ) print(''' ''' * 9 + '''System Resource Table''' ) for item in self.__maximum_claim_table: print( F"""P{self.__maximum_claim_table.index(__UpperCAmelCase ) + 1}""" + ''' '''.join(F"""{it:>8}""" for it in item ) + '''\n''' ) print( '''Current Usage by Active Processes: ''' + ''' '''.join(str(__UpperCAmelCase ) for x in self.__claim_vector ) ) print( '''Initial Available Resources: ''' + ''' '''.join(str(__UpperCAmelCase ) for x in self.__available_resources() ) ) time.sleep(1 ) if __name__ == "__main__": import doctest doctest.testmod()

import argparse import torch from transformers import LxmertConfig, LxmertForPreTraining, load_tf_weights_in_lxmert from transformers.utils import logging logging.set_verbosity_info() def lowerCamelCase__ ( a__ : Optional[Any] , a__ : Dict , a__ : Any ) -> int: # Initialise PyTorch model UpperCamelCase_ = LxmertConfig.from_json_file(a_ ) print(f'''Building PyTorch model from configuration: {config}''' ) UpperCamelCase_ = LxmertForPreTraining(a_ ) # Load weights from tf checkpoint load_tf_weights_in_lxmert(a_ , a_ , a_ ) # Save pytorch-model print(f'''Save PyTorch model to {pytorch_dump_path}''' ) torch.save(model.state_dict() , a_ ) if __name__ == "__main__": _A = argparse.ArgumentParser() # Required parameters parser.add_argument( '''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.''' ) parser.add_argument( '''--config_file''', default=None, type=str, required=True, help='''The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.''', ) parser.add_argument( '''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.''' ) _A = parser.parse_args() convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)

import math def lowerCamelCase__ ( a__ : float , a__ : float ) -> float: if ( not isinstance(a__ , (int, float) ) or power_factor < -1 or power_factor > 1 ): raise ValueError("""power_factor must be a valid float value between -1 and 1.""" ) return apparent_power * power_factor def lowerCamelCase__ ( a__ : float , a__ : float ) -> float: if ( not isinstance(a__ , (int, float) ) or power_factor < -1 or power_factor > 1 ): raise ValueError("""power_factor must be a valid float value between -1 and 1.""" ) return apparent_power * math.sqrt(1 - power_factor**2 ) if __name__ == "__main__": import doctest doctest.testmod()

"""simple docstring""" import contextlib import csv import json import os import sqlitea import tarfile import textwrap import zipfile import pyarrow as pa import pyarrow.parquet as pq import pytest import datasets import datasets.config @pytest.fixture(scope="session") def _A ( ) -> Any: '''simple docstring''' __lowercase = 10 __lowercase = datasets.Features( { "tokens": datasets.Sequence(datasets.Value("string")), "labels": datasets.Sequence(datasets.ClassLabel(names=["negative", "positive"])), "answers": datasets.Sequence( { "text": datasets.Value("string"), "answer_start": datasets.Value("int32"), }), "id": datasets.Value("int64"), }) __lowercase = datasets.Dataset.from_dict( { "tokens": [["foo"] * 5] * n, "labels": [[1] * 5] * n, "answers": [{"answer_start": [97], "text": ["1976"]}] * 10, "id": list(range(UpperCamelCase_)), }, features=UpperCamelCase_, ) return dataset @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Union[str, Any], UpperCamelCase_ : Optional[int]) -> Any: '''simple docstring''' __lowercase = str(tmp_path_factory.mktemp("data") / "file.arrow") dataset.map(cache_file_name=UpperCamelCase_) return filename # FILE_CONTENT + files _a = '\\n Text data.\n Second line of data.' @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Optional[int]) -> List[Any]: '''simple docstring''' __lowercase = tmp_path_factory.mktemp("data") / "file.txt" __lowercase = FILE_CONTENT with open(UpperCamelCase_, "w") as f: f.write(UpperCamelCase_) return filename @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : int) -> Any: '''simple docstring''' import bza __lowercase = tmp_path_factory.mktemp("data") / "file.txt.bz2" __lowercase = bytes(UpperCamelCase_, "utf-8") with bza.open(UpperCamelCase_, "wb") as f: f.write(UpperCamelCase_) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Union[str, Any]) -> Optional[Any]: '''simple docstring''' import gzip __lowercase = str(tmp_path_factory.mktemp("data") / "file.txt.gz") __lowercase = bytes(UpperCamelCase_, "utf-8") with gzip.open(UpperCamelCase_, "wb") as f: f.write(UpperCamelCase_) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Tuple) -> Union[str, Any]: '''simple docstring''' if datasets.config.LZ4_AVAILABLE: import lza.frame __lowercase = tmp_path_factory.mktemp("data") / "file.txt.lz4" __lowercase = bytes(UpperCamelCase_, "utf-8") with lza.frame.open(UpperCamelCase_, "wb") as f: f.write(UpperCamelCase_) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : str, UpperCamelCase_ : Any) -> Optional[Any]: '''simple docstring''' if datasets.config.PY7ZR_AVAILABLE: import pyazr __lowercase = tmp_path_factory.mktemp("data") / "file.txt.7z" with pyazr.SevenZipFile(UpperCamelCase_, "w") as archive: archive.write(UpperCamelCase_, arcname=os.path.basename(UpperCamelCase_)) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : List[str], UpperCamelCase_ : Union[str, Any]) -> Optional[Any]: '''simple docstring''' import tarfile __lowercase = tmp_path_factory.mktemp("data") / "file.txt.tar" with tarfile.TarFile(UpperCamelCase_, "w") as f: f.add(UpperCamelCase_, arcname=os.path.basename(UpperCamelCase_)) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Optional[int]) -> int: '''simple docstring''' import lzma __lowercase = tmp_path_factory.mktemp("data") / "file.txt.xz" __lowercase = bytes(UpperCamelCase_, "utf-8") with lzma.open(UpperCamelCase_, "wb") as f: f.write(UpperCamelCase_) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Tuple, UpperCamelCase_ : Tuple) -> int: '''simple docstring''' import zipfile __lowercase = tmp_path_factory.mktemp("data") / "file.txt.zip" with zipfile.ZipFile(UpperCamelCase_, "w") as f: f.write(UpperCamelCase_, arcname=os.path.basename(UpperCamelCase_)) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : str) -> Union[str, Any]: '''simple docstring''' if datasets.config.ZSTANDARD_AVAILABLE: import zstandard as zstd __lowercase = tmp_path_factory.mktemp("data") / "file.txt.zst" __lowercase = bytes(UpperCamelCase_, "utf-8") with zstd.open(UpperCamelCase_, "wb") as f: f.write(UpperCamelCase_) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : List[Any]) -> Optional[Any]: '''simple docstring''' __lowercase = tmp_path_factory.mktemp("data") / "file.xml" __lowercase = textwrap.dedent( "\\n <?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n <tmx version=\"1.4\">\n <header segtype=\"sentence\" srclang=\"ca\" />\n <body>\n <tu>\n <tuv xml:lang=\"ca\"><seg>Contingut 1</seg></tuv>\n <tuv xml:lang=\"en\"><seg>Content 1</seg></tuv>\n </tu>\n <tu>\n <tuv xml:lang=\"ca\"><seg>Contingut 2</seg></tuv>\n <tuv xml:lang=\"en\"><seg>Content 2</seg></tuv>\n </tu>\n <tu>\n <tuv xml:lang=\"ca\"><seg>Contingut 3</seg></tuv>\n <tuv xml:lang=\"en\"><seg>Content 3</seg></tuv>\n </tu>\n <tu>\n <tuv xml:lang=\"ca\"><seg>Contingut 4</seg></tuv>\n <tuv xml:lang=\"en\"><seg>Content 4</seg></tuv>\n </tu>\n <tu>\n <tuv xml:lang=\"ca\"><seg>Contingut 5</seg></tuv>\n <tuv xml:lang=\"en\"><seg>Content 5</seg></tuv>\n </tu>\n </body>\n </tmx>") with open(UpperCamelCase_, "w") as f: f.write(UpperCamelCase_) return filename _a = [ {'col_1': '0', 'col_2': 0, 'col_3': 0.0}, {'col_1': '1', 'col_2': 1, 'col_3': 1.0}, {'col_1': '2', 'col_2': 2, 'col_3': 2.0}, {'col_1': '3', 'col_2': 3, 'col_3': 3.0}, ] _a = [ {'col_1': '4', 'col_2': 4, 'col_3': 4.0}, {'col_1': '5', 'col_2': 5, 'col_3': 5.0}, ] _a = { 'col_1': ['0', '1', '2', '3'], 'col_2': [0, 1, 2, 3], 'col_3': [0.0, 1.0, 2.0, 3.0], } _a = [ {'col_3': 0.0, 'col_1': '0', 'col_2': 0}, {'col_3': 1.0, 'col_1': '1', 'col_2': 1}, ] _a = [ {'col_1': 's0', 'col_2': 0, 'col_3': 0.0}, {'col_1': 's1', 'col_2': 1, 'col_3': 1.0}, {'col_1': 's2', 'col_2': 2, 'col_3': 2.0}, {'col_1': 's3', 'col_2': 3, 'col_3': 3.0}, ] @pytest.fixture(scope="session") def _A ( ) -> Any: '''simple docstring''' return DATA_DICT_OF_LISTS @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Union[str, Any]) -> Optional[Any]: '''simple docstring''' __lowercase = datasets.Dataset.from_dict(UpperCamelCase_) __lowercase = str(tmp_path_factory.mktemp("data") / "dataset.arrow") dataset.map(cache_file_name=UpperCamelCase_) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Optional[Any]) -> Union[str, Any]: '''simple docstring''' __lowercase = str(tmp_path_factory.mktemp("data") / "dataset.sqlite") with contextlib.closing(sqlitea.connect(UpperCamelCase_)) as con: __lowercase = con.cursor() cur.execute("CREATE TABLE dataset(col_1 text, col_2 int, col_3 real)") for item in DATA: cur.execute("INSERT INTO dataset(col_1, col_2, col_3) VALUES (?, ?, ?)", tuple(item.values())) con.commit() return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Any) -> int: '''simple docstring''' __lowercase = str(tmp_path_factory.mktemp("data") / "dataset.csv") with open(UpperCamelCase_, "w", newline="") as f: __lowercase = csv.DictWriter(UpperCamelCase_, fieldnames=["col_1", "col_2", "col_3"]) writer.writeheader() for item in DATA: writer.writerow(UpperCamelCase_) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Dict) -> Dict: '''simple docstring''' __lowercase = str(tmp_path_factory.mktemp("data") / "dataset2.csv") with open(UpperCamelCase_, "w", newline="") as f: __lowercase = csv.DictWriter(UpperCamelCase_, fieldnames=["col_1", "col_2", "col_3"]) writer.writeheader() for item in DATA: writer.writerow(UpperCamelCase_) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Dict, UpperCamelCase_ : int) -> Optional[Any]: '''simple docstring''' import bza __lowercase = tmp_path_factory.mktemp("data") / "dataset.csv.bz2" with open(UpperCamelCase_, "rb") as f: __lowercase = f.read() # data = bytes(FILE_CONTENT, "utf-8") with bza.open(UpperCamelCase_, "wb") as f: f.write(UpperCamelCase_) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Dict, UpperCamelCase_ : Dict, UpperCamelCase_ : List[str]) -> str: '''simple docstring''' __lowercase = tmp_path_factory.mktemp("data") / "dataset.csv.zip" with zipfile.ZipFile(UpperCamelCase_, "w") as f: f.write(UpperCamelCase_, arcname=os.path.basename(UpperCamelCase_)) f.write(UpperCamelCase_, arcname=os.path.basename(UpperCamelCase_)) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : List[Any], UpperCamelCase_ : str, UpperCamelCase_ : Optional[Any]) -> Union[str, Any]: '''simple docstring''' __lowercase = tmp_path_factory.mktemp("data") / "dataset.csv.zip" with zipfile.ZipFile(UpperCamelCase_, "w") as f: f.write(UpperCamelCase_, arcname=os.path.basename(csv_path.replace(".csv", ".CSV"))) f.write(UpperCamelCase_, arcname=os.path.basename(csva_path.replace(".csv", ".CSV"))) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Tuple, UpperCamelCase_ : Union[str, Any], UpperCamelCase_ : int) -> int: '''simple docstring''' __lowercase = tmp_path_factory.mktemp("data") / "dataset_with_dir.csv.zip" with zipfile.ZipFile(UpperCamelCase_, "w") as f: f.write(UpperCamelCase_, arcname=os.path.join("main_dir", os.path.basename(UpperCamelCase_))) f.write(UpperCamelCase_, arcname=os.path.join("main_dir", os.path.basename(UpperCamelCase_))) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : List[str]) -> Union[str, Any]: '''simple docstring''' __lowercase = str(tmp_path_factory.mktemp("data") / "dataset.parquet") __lowercase = pa.schema( { "col_1": pa.string(), "col_2": pa.intaa(), "col_3": pa.floataa(), }) with open(UpperCamelCase_, "wb") as f: __lowercase = pq.ParquetWriter(UpperCamelCase_, schema=UpperCamelCase_) __lowercase = pa.Table.from_pydict({k: [DATA[i][k] for i in range(len(UpperCamelCase_))] for k in DATA[0]}, schema=UpperCamelCase_) writer.write_table(UpperCamelCase_) writer.close() return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : str) -> Tuple: '''simple docstring''' __lowercase = str(tmp_path_factory.mktemp("data") / "dataset.json") __lowercase = {"data": DATA} with open(UpperCamelCase_, "w") as f: json.dump(UpperCamelCase_, UpperCamelCase_) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Optional[Any]) -> Any: '''simple docstring''' __lowercase = str(tmp_path_factory.mktemp("data") / "dataset.json") __lowercase = {"data": DATA_DICT_OF_LISTS} with open(UpperCamelCase_, "w") as f: json.dump(UpperCamelCase_, UpperCamelCase_) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : str) -> int: '''simple docstring''' __lowercase = str(tmp_path_factory.mktemp("data") / "dataset.jsonl") with open(UpperCamelCase_, "w") as f: for item in DATA: f.write(json.dumps(UpperCamelCase_) + "\n") return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Optional[int]) -> Tuple: '''simple docstring''' __lowercase = str(tmp_path_factory.mktemp("data") / "dataset2.jsonl") with open(UpperCamelCase_, "w") as f: for item in DATA: f.write(json.dumps(UpperCamelCase_) + "\n") return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : str) -> Any: '''simple docstring''' __lowercase = str(tmp_path_factory.mktemp("data") / "dataset_312.jsonl") with open(UpperCamelCase_, "w") as f: for item in DATA_312: f.write(json.dumps(UpperCamelCase_) + "\n") return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Dict) -> Tuple: '''simple docstring''' __lowercase = str(tmp_path_factory.mktemp("data") / "dataset-str.jsonl") with open(UpperCamelCase_, "w") as f: for item in DATA_STR: f.write(json.dumps(UpperCamelCase_) + "\n") return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Tuple, UpperCamelCase_ : int) -> Union[str, Any]: '''simple docstring''' import gzip __lowercase = str(tmp_path_factory.mktemp("data") / "dataset.txt.gz") with open(UpperCamelCase_, "rb") as orig_file: with gzip.open(UpperCamelCase_, "wb") as zipped_file: zipped_file.writelines(UpperCamelCase_) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Tuple, UpperCamelCase_ : List[str]) -> List[str]: '''simple docstring''' import gzip __lowercase = str(tmp_path_factory.mktemp("data") / "dataset.jsonl.gz") with open(UpperCamelCase_, "rb") as orig_file: with gzip.open(UpperCamelCase_, "wb") as zipped_file: zipped_file.writelines(UpperCamelCase_) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Dict, UpperCamelCase_ : Any, UpperCamelCase_ : Union[str, Any]) -> Tuple: '''simple docstring''' __lowercase = tmp_path_factory.mktemp("data") / "dataset.jsonl.zip" with zipfile.ZipFile(UpperCamelCase_, "w") as f: f.write(UpperCamelCase_, arcname=os.path.basename(UpperCamelCase_)) f.write(UpperCamelCase_, arcname=os.path.basename(UpperCamelCase_)) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : List[Any], UpperCamelCase_ : Dict, UpperCamelCase_ : List[Any], UpperCamelCase_ : List[str]) -> Union[str, Any]: '''simple docstring''' __lowercase = tmp_path_factory.mktemp("data") / "dataset_nested.jsonl.zip" with zipfile.ZipFile(UpperCamelCase_, "w") as f: f.write(UpperCamelCase_, arcname=os.path.join("nested", os.path.basename(UpperCamelCase_))) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Any, UpperCamelCase_ : List[Any], UpperCamelCase_ : Union[str, Any]) -> Dict: '''simple docstring''' __lowercase = tmp_path_factory.mktemp("data") / "dataset_with_dir.jsonl.zip" with zipfile.ZipFile(UpperCamelCase_, "w") as f: f.write(UpperCamelCase_, arcname=os.path.join("main_dir", os.path.basename(UpperCamelCase_))) f.write(UpperCamelCase_, arcname=os.path.join("main_dir", os.path.basename(UpperCamelCase_))) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Optional[int], UpperCamelCase_ : List[Any], UpperCamelCase_ : Dict) -> Tuple: '''simple docstring''' __lowercase = tmp_path_factory.mktemp("data") / "dataset.jsonl.tar" with tarfile.TarFile(UpperCamelCase_, "w") as f: f.add(UpperCamelCase_, arcname=os.path.basename(UpperCamelCase_)) f.add(UpperCamelCase_, arcname=os.path.basename(UpperCamelCase_)) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Dict, UpperCamelCase_ : str, UpperCamelCase_ : Optional[Any], UpperCamelCase_ : Optional[int]) -> Optional[Any]: '''simple docstring''' __lowercase = tmp_path_factory.mktemp("data") / "dataset_nested.jsonl.tar" with tarfile.TarFile(UpperCamelCase_, "w") as f: f.add(UpperCamelCase_, arcname=os.path.join("nested", os.path.basename(UpperCamelCase_))) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Any) -> Dict: '''simple docstring''' __lowercase = ["0", "1", "2", "3"] __lowercase = str(tmp_path_factory.mktemp("data") / "dataset.txt") with open(UpperCamelCase_, "w") as f: for item in data: f.write(item + "\n") return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : str) -> str: '''simple docstring''' __lowercase = ["0", "1", "2", "3"] __lowercase = str(tmp_path_factory.mktemp("data") / "dataset2.txt") with open(UpperCamelCase_, "w") as f: for item in data: f.write(item + "\n") return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : str) -> Optional[Any]: '''simple docstring''' __lowercase = ["0", "1", "2", "3"] __lowercase = tmp_path_factory.mktemp("data") / "dataset.abc" with open(UpperCamelCase_, "w") as f: for item in data: f.write(item + "\n") return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : List[Any], UpperCamelCase_ : Optional[Any], UpperCamelCase_ : Union[str, Any]) -> str: '''simple docstring''' __lowercase = tmp_path_factory.mktemp("data") / "dataset.text.zip" with zipfile.ZipFile(UpperCamelCase_, "w") as f: f.write(UpperCamelCase_, arcname=os.path.basename(UpperCamelCase_)) f.write(UpperCamelCase_, arcname=os.path.basename(UpperCamelCase_)) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : str, UpperCamelCase_ : Dict, UpperCamelCase_ : int) -> Tuple: '''simple docstring''' __lowercase = tmp_path_factory.mktemp("data") / "dataset_with_dir.text.zip" with zipfile.ZipFile(UpperCamelCase_, "w") as f: f.write(UpperCamelCase_, arcname=os.path.join("main_dir", os.path.basename(UpperCamelCase_))) f.write(UpperCamelCase_, arcname=os.path.join("main_dir", os.path.basename(UpperCamelCase_))) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : int, UpperCamelCase_ : str, UpperCamelCase_ : Optional[int]) -> Optional[int]: '''simple docstring''' __lowercase = tmp_path_factory.mktemp("data") / "dataset.ext.zip" with zipfile.ZipFile(UpperCamelCase_, "w") as f: f.write(UpperCamelCase_, arcname=os.path.basename("unsupported.ext")) f.write(UpperCamelCase_, arcname=os.path.basename("unsupported_2.ext")) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Dict) -> Union[str, Any]: '''simple docstring''' __lowercase = "\n".join(["First", "Second\u2029with Unicode new line", "Third"]) __lowercase = str(tmp_path_factory.mktemp("data") / "dataset_with_unicode_new_lines.txt") with open(UpperCamelCase_, "w", encoding="utf-8") as f: f.write(UpperCamelCase_) return path @pytest.fixture(scope="session") def _A ( ) -> Any: '''simple docstring''' return os.path.join("tests", "features", "data", "test_image_rgb.jpg") @pytest.fixture(scope="session") def _A ( ) -> Union[str, Any]: '''simple docstring''' return os.path.join("tests", "features", "data", "test_audio_44100.wav") @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Tuple, UpperCamelCase_ : List[str]) -> Tuple: '''simple docstring''' __lowercase = tmp_path_factory.mktemp("data") / "dataset.img.zip" with zipfile.ZipFile(UpperCamelCase_, "w") as f: f.write(UpperCamelCase_, arcname=os.path.basename(UpperCamelCase_)) f.write(UpperCamelCase_, arcname=os.path.basename(UpperCamelCase_).replace(".jpg", "2.jpg")) return path @pytest.fixture(scope="session") def _A ( UpperCamelCase_ : Union[str, Any]) -> Optional[Any]: '''simple docstring''' __lowercase = tmp_path_factory.mktemp("data_dir") (data_dir / "subdir").mkdir() with open(data_dir / "subdir" / "train.txt", "w") as f: f.write("foo\n" * 10) with open(data_dir / "subdir" / "test.txt", "w") as f: f.write("bar\n" * 10) # hidden file with open(data_dir / "subdir" / ".test.txt", "w") as f: f.write("bar\n" * 10) # hidden directory (data_dir / ".subdir").mkdir() with open(data_dir / ".subdir" / "train.txt", "w") as f: f.write("foo\n" * 10) with open(data_dir / ".subdir" / "test.txt", "w") as f: f.write("bar\n" * 10) return data_dir

import argparse import datetime def lowerCAmelCase__( lowercase : str ) -> str: __snake_case : int = { "0": "Sunday", "1": "Monday", "2": "Tuesday", "3": "Wednesday", "4": "Thursday", "5": "Friday", "6": "Saturday", } __snake_case : int = {0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 0} # Validate if not 0 < len(lowercase ) < 11: raise ValueError("Must be 10 characters long" ) # Get month __snake_case : int = int(date_input[0] + date_input[1] ) # Validate if not 0 < m < 13: raise ValueError("Month must be between 1 - 12" ) __snake_case : str = date_input[2] # Validate if sep_a not in ["-", "/"]: raise ValueError("Date separator must be '-' or '/'" ) # Get day __snake_case : int = int(date_input[3] + date_input[4] ) # Validate if not 0 < d < 32: raise ValueError("Date must be between 1 - 31" ) # Get second separator __snake_case : str = date_input[5] # Validate if sep_a not in ["-", "/"]: raise ValueError("Date separator must be '-' or '/'" ) # Get year __snake_case : int = int(date_input[6] + date_input[7] + date_input[8] + date_input[9] ) # Arbitrary year range if not 45 < y < 8500: raise ValueError( "Year out of range. There has to be some sort of limit...right?" ) # Get datetime obj for validation __snake_case : str = datetime.date(int(lowercase ) , int(lowercase ) , int(lowercase ) ) # Start math if m <= 2: __snake_case : Optional[Any] = y - 1 __snake_case : Tuple = m + 12 # maths var __snake_case : int = int(str(lowercase )[:2] ) __snake_case : int = int(str(lowercase )[2:] ) __snake_case : int = int(2.6 * m - 5.3_9 ) __snake_case : int = int(c / 4 ) __snake_case : int = int(k / 4 ) __snake_case : int = int(d + k ) __snake_case : int = int(t + u + v + x ) __snake_case : int = int(z - (2 * c) ) __snake_case : int = round(w % 7 ) # End math # Validate math if f != convert_datetime_days[dt_ck.weekday()]: raise AssertionError("The date was evaluated incorrectly. Contact developer." ) # Response __snake_case : str = f"""Your date {date_input}, is a {days[str(lowercase )]}!""" return response if __name__ == "__main__": import doctest doctest.testmod() _UpperCamelCase = argparse.ArgumentParser( description=( '''Find out what day of the week nearly any date is or was. Enter ''' '''date as a string in the mm-dd-yyyy or mm/dd/yyyy format''' ) ) parser.add_argument( '''date_input''', type=str, help='''Date as a string (mm-dd-yyyy or mm/dd/yyyy)''' ) _UpperCamelCase = parser.parse_args() zeller(args.date_input)

from __future__ import annotations import unittest from transformers import is_tf_available from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow if is_tf_available(): import tensorflow as tf from transformers import AutoTokenizer, TFAutoModelForSeqaSeqLM @require_tf @require_sentencepiece @require_tokenizers class __SCREAMING_SNAKE_CASE ( unittest.TestCase): @slow def UpperCamelCase__ ( self ): """simple docstring""" lowerCAmelCase__ = TFAutoModelForSeqaSeqLM.from_pretrained('google/mt5-small' ) lowerCAmelCase__ = AutoTokenizer.from_pretrained('google/mt5-small' ) lowerCAmelCase__ = tokenizer('Hello there' , return_tensors='tf' ).input_ids lowerCAmelCase__ = tokenizer('Hi I am' , return_tensors='tf' ).input_ids lowerCAmelCase__ = model(_UpperCamelCase , labels=_UpperCamelCase ).loss lowerCAmelCase__ = -tf.math.reduce_mean(_UpperCamelCase ).numpy() lowerCAmelCase__ = -21.22_81_68 self.assertTrue(abs(mtf_score - EXPECTED_SCORE ) < 2E-4 )

from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_tokenizers_available, is_torch_available, ) __snake_case : Union[str, Any] = { """configuration_convbert""": ["""CONVBERT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """ConvBertConfig""", """ConvBertOnnxConfig"""], """tokenization_convbert""": ["""ConvBertTokenizer"""], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __snake_case : List[str] = ["""ConvBertTokenizerFast"""] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __snake_case : Optional[Any] = [ """CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST""", """ConvBertForMaskedLM""", """ConvBertForMultipleChoice""", """ConvBertForQuestionAnswering""", """ConvBertForSequenceClassification""", """ConvBertForTokenClassification""", """ConvBertLayer""", """ConvBertModel""", """ConvBertPreTrainedModel""", """load_tf_weights_in_convbert""", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __snake_case : Union[str, Any] = [ """TF_CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST""", """TFConvBertForMaskedLM""", """TFConvBertForMultipleChoice""", """TFConvBertForQuestionAnswering""", """TFConvBertForSequenceClassification""", """TFConvBertForTokenClassification""", """TFConvBertLayer""", """TFConvBertModel""", """TFConvBertPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_convbert import CONVBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ConvBertConfig, ConvBertOnnxConfig from .tokenization_convbert import ConvBertTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_convbert_fast import ConvBertTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_convbert import ( CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST, ConvBertForMaskedLM, ConvBertForMultipleChoice, ConvBertForQuestionAnswering, ConvBertForSequenceClassification, ConvBertForTokenClassification, ConvBertLayer, ConvBertModel, ConvBertPreTrainedModel, load_tf_weights_in_convbert, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_convbert import ( TF_CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST, TFConvBertForMaskedLM, TFConvBertForMultipleChoice, TFConvBertForQuestionAnswering, TFConvBertForSequenceClassification, TFConvBertForTokenClassification, TFConvBertLayer, TFConvBertModel, TFConvBertPreTrainedModel, ) else: import sys __snake_case : Dict = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

'''simple docstring''' import torch def SCREAMING_SNAKE_CASE( ) -> Optional[int]: if torch.cuda.is_available(): A: Optional[int] = torch.cuda.device_count() else: A: Dict = 0 print(F"""Successfully ran on {num_gpus} GPUs""" ) if __name__ == "__main__": main()

from typing import TYPE_CHECKING from ....utils import _LazyModule _UpperCAmelCase : Dict = {"tokenization_tapex": ["TapexTokenizer"]} if TYPE_CHECKING: from .tokenization_tapex import TapexTokenizer else: import sys _UpperCAmelCase : Optional[Any] = _LazyModule(__name__, globals()["__file__"], _import_structure)

import collections import inspect import unittest from typing import Dict, List, Tuple from transformers import MaskFormerSwinConfig from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device from transformers.utils import is_torch_available from ...test_backbone_common import BackboneTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from torch import nn from transformers import MaskFormerSwinBackbone from transformers.models.maskformer import MaskFormerSwinModel class lowerCamelCase__ : def __init__( self : Union[str, Any] , _a : Any , _a : str=1_3 , _a : Dict=3_2 , _a : Optional[int]=2 , _a : Dict=3 , _a : Dict=1_6 , _a : Optional[int]=[1, 2, 1] , _a : int=[2, 2, 4] , _a : Optional[Any]=2 , _a : Optional[Any]=2.0 , _a : Tuple=True , _a : Tuple=0.0 , _a : Optional[int]=0.0 , _a : Any=0.1 , _a : List[str]="gelu" , _a : Any=False , _a : Optional[Any]=True , _a : Optional[int]=0.0_2 , _a : Any=1e-5 , _a : Dict=True , _a : str=None , _a : Tuple=True , _a : Dict=1_0 , _a : Any=8 , _a : List[Any]=["stage1", "stage2", "stage3"] , _a : Any=[1, 2, 3] , ): a__: Tuple =parent a__: Union[str, Any] =batch_size a__: int =image_size a__: Union[str, Any] =patch_size a__: Optional[Any] =num_channels a__: int =embed_dim a__: Optional[Any] =depths a__: Optional[Any] =num_heads a__: str =window_size a__: Optional[Any] =mlp_ratio a__: Dict =qkv_bias a__: List[str] =hidden_dropout_prob a__: Any =attention_probs_dropout_prob a__: Optional[int] =drop_path_rate a__: List[str] =hidden_act a__: Optional[Any] =use_absolute_embeddings a__: Tuple =patch_norm a__: Union[str, Any] =layer_norm_eps a__: List[str] =initializer_range a__: str =is_training a__: List[Any] =scope a__: Dict =use_labels a__: Any =type_sequence_label_size a__: Union[str, Any] =encoder_stride a__: Union[str, Any] =out_features a__: Any =out_indices def _lowerCamelCase ( self : Union[str, Any] ): a__: List[Any] =floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) a__: Dict =None if self.use_labels: a__: Optional[Any] =ids_tensor([self.batch_size] , self.type_sequence_label_size ) a__: str =self.get_config() return config, pixel_values, labels def _lowerCamelCase ( self : int ): return MaskFormerSwinConfig( image_size=self.image_size , patch_size=self.patch_size , num_channels=self.num_channels , embed_dim=self.embed_dim , depths=self.depths , num_heads=self.num_heads , window_size=self.window_size , mlp_ratio=self.mlp_ratio , qkv_bias=self.qkv_bias , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , drop_path_rate=self.drop_path_rate , hidden_act=self.hidden_act , use_absolute_embeddings=self.use_absolute_embeddings , path_norm=self.patch_norm , layer_norm_eps=self.layer_norm_eps , initializer_range=self.initializer_range , encoder_stride=self.encoder_stride , out_features=self.out_features , out_indices=self.out_indices , ) def _lowerCamelCase ( self : List[Any] , _a : Optional[Any] , _a : Union[str, Any] , _a : Any ): a__: Tuple =MaskFormerSwinModel(config=_a ) model.to(_a ) model.eval() a__: Union[str, Any] =model(_a ) a__: int =((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths ) - 1)) a__: List[str] =int(config.embed_dim * 2 ** (len(config.depths ) - 1) ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, expected_seq_len, expected_dim) ) def _lowerCamelCase ( self : str , _a : List[str] , _a : Any , _a : int ): a__: Tuple =MaskFormerSwinBackbone(config=_a ) model.to(_a ) model.eval() a__: List[str] =model(_a ) # verify feature maps self.parent.assertEqual(len(result.feature_maps ) , len(config.out_features ) ) self.parent.assertListEqual(list(result.feature_maps[0].shape ) , [1_3, 1_6, 1_6, 1_6] ) # verify channels self.parent.assertEqual(len(model.channels ) , len(config.out_features ) ) self.parent.assertListEqual(model.channels , [1_6, 3_2, 6_4] ) # verify ValueError with self.parent.assertRaises(_a ): a__: Optional[Any] =["stem"] a__: Optional[Any] =MaskFormerSwinBackbone(config=_a ) def _lowerCamelCase ( self : Tuple ): a__: List[Any] =self.prepare_config_and_inputs() a__ , a__ , a__: Any =config_and_inputs a__: Union[str, Any] ={"pixel_values": pixel_values} return config, inputs_dict @require_torch class lowerCamelCase__ ( _a , _a , unittest.TestCase ): _lowerCAmelCase = ( ( MaskFormerSwinModel, MaskFormerSwinBackbone, ) if is_torch_available() else () ) _lowerCAmelCase = {'''feature-extraction''': MaskFormerSwinModel} if is_torch_available() else {} _lowerCAmelCase = False _lowerCAmelCase = False _lowerCAmelCase = False _lowerCAmelCase = False _lowerCAmelCase = False def _lowerCamelCase ( self : Union[str, Any] ): a__: Tuple =MaskFormerSwinModelTester(self ) a__: Any =ConfigTester(self , config_class=_a , embed_dim=3_7 ) @require_torch_multi_gpu @unittest.skip( reason=( "`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn't work well with" " `nn.DataParallel`" ) ) def _lowerCamelCase ( self : Any ): pass def _lowerCamelCase ( self : int ): self.create_and_test_config_common_properties() self.config_tester.create_and_test_config_to_json_string() self.config_tester.create_and_test_config_to_json_file() self.config_tester.create_and_test_config_from_and_save_pretrained() self.config_tester.create_and_test_config_with_num_labels() self.config_tester.check_config_can_be_init_without_params() self.config_tester.check_config_arguments_init() def _lowerCamelCase ( self : Tuple ): return def _lowerCamelCase ( self : List[str] ): a__: Dict =self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*_a ) def _lowerCamelCase ( self : str ): a__: List[Any] =self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_backbone(*_a ) @unittest.skip("Swin does not use inputs_embeds" ) def _lowerCamelCase ( self : Optional[int] ): pass @unittest.skip("Swin does not support feedforward chunking" ) def _lowerCamelCase ( self : int ): pass def _lowerCamelCase ( self : List[Any] ): a__ , a__: List[Any] =self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: a__: List[str] =model_class(_a ) self.assertIsInstance(model.get_input_embeddings() , (nn.Module) ) a__: Optional[Any] =model.get_output_embeddings() self.assertTrue(x is None or isinstance(_a , nn.Linear ) ) def _lowerCamelCase ( self : Union[str, Any] ): a__ , a__: Optional[int] =self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: a__: List[Any] =model_class(_a ) a__: Any =inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic a__: Optional[int] =[*signature.parameters.keys()] a__: List[str] =["pixel_values"] self.assertListEqual(arg_names[:1] , _a ) @unittest.skip(reason="MaskFormerSwin is only used as backbone and doesn't support output_attentions" ) def _lowerCamelCase ( self : Optional[int] ): pass @unittest.skip(reason="MaskFormerSwin is only used as an internal backbone" ) def _lowerCamelCase ( self : List[Any] ): pass def _lowerCamelCase ( self : Tuple , _a : Dict , _a : Union[str, Any] , _a : Tuple , _a : Union[str, Any] ): a__: Optional[int] =model_class(_a ) model.to(_a ) model.eval() with torch.no_grad(): a__: Optional[int] =model(**self._prepare_for_class(_a , _a ) ) a__: List[Any] =outputs.hidden_states a__: Tuple =getattr( self.model_tester , "expected_num_hidden_layers" , len(self.model_tester.depths ) + 1 ) self.assertEqual(len(_a ) , _a ) # Swin has a different seq_length a__: Tuple =( config.patch_size if isinstance(config.patch_size , collections.abc.Iterable ) else (config.patch_size, config.patch_size) ) a__: Optional[Any] =(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0]) self.assertListEqual( list(hidden_states[0].shape[-2:] ) , [num_patches, self.model_tester.embed_dim] , ) def _lowerCamelCase ( self : Union[str, Any] ): a__ , a__: Tuple =self.model_tester.prepare_config_and_inputs_for_common() a__: Optional[int] =( self.model_tester.image_size if isinstance(self.model_tester.image_size , collections.abc.Iterable ) else (self.model_tester.image_size, self.model_tester.image_size) ) for model_class in self.all_model_classes: a__: Tuple =True self.check_hidden_states_output(_a , _a , _a , _a ) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] a__: List[str] =True self.check_hidden_states_output(_a , _a , _a , _a ) def _lowerCamelCase ( self : Optional[Any] ): a__ , a__: Optional[Any] =self.model_tester.prepare_config_and_inputs_for_common() a__: Dict =3 a__: Dict =( self.model_tester.image_size if isinstance(self.model_tester.image_size , collections.abc.Iterable ) else (self.model_tester.image_size, self.model_tester.image_size) ) a__: str =( config.patch_size if isinstance(config.patch_size , collections.abc.Iterable ) else (config.patch_size, config.patch_size) ) a__: Optional[Any] =image_size[0] + patch_size[0] - (image_size[0] % patch_size[0]) a__: int =image_size[1] + patch_size[1] - (image_size[1] % patch_size[1]) for model_class in self.all_model_classes: a__: List[str] =True self.check_hidden_states_output(_a , _a , _a , (padded_height, padded_width) ) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] a__: Optional[int] =True self.check_hidden_states_output(_a , _a , _a , (padded_height, padded_width) ) @unittest.skip(reason="MaskFormerSwin doesn't have pretrained checkpoints" ) def _lowerCamelCase ( self : Optional[int] ): pass @unittest.skip(reason="This will be fixed once MaskFormerSwin is replaced by native Swin" ) def _lowerCamelCase ( self : Optional[int] ): pass @unittest.skip(reason="This will be fixed once MaskFormerSwin is replaced by native Swin" ) def _lowerCamelCase ( self : Union[str, Any] ): pass def _lowerCamelCase ( self : Tuple ): a__ , a__: Optional[Any] =self.model_tester.prepare_config_and_inputs_for_common() def set_nan_tensor_to_zero(_a : Dict ): a__: Tuple =0 return t def check_equivalence(_a : Tuple , _a : Tuple , _a : Tuple , _a : List[str]={} ): with torch.no_grad(): a__: Optional[Any] =model(**_a , return_dict=_a , **_a ) a__: int =model(**_a , return_dict=_a , **_a ).to_tuple() def recursive_check(_a : Dict , _a : str ): if isinstance(_a , (List, Tuple) ): for tuple_iterable_value, dict_iterable_value in zip(_a , _a ): recursive_check(_a , _a ) elif isinstance(_a , _a ): for tuple_iterable_value, dict_iterable_value in zip( tuple_object.values() , dict_object.values() ): recursive_check(_a , _a ) elif tuple_object is None: return else: self.assertTrue( torch.allclose( set_nan_tensor_to_zero(_a ) , set_nan_tensor_to_zero(_a ) , atol=1e-5 ) , msg=( "Tuple and dict output are not equal. Difference:" F" {torch.max(torch.abs(tuple_object - dict_object ) )}. Tuple has `nan`:" F" {torch.isnan(_a ).any()} and `inf`: {torch.isinf(_a )}. Dict has" F" `nan`: {torch.isnan(_a ).any()} and `inf`: {torch.isinf(_a )}." ) , ) recursive_check(_a , _a ) for model_class in self.all_model_classes: a__: str =model_class(_a ) model.to(_a ) model.eval() a__: str =self._prepare_for_class(_a , _a ) a__: Union[str, Any] =self._prepare_for_class(_a , _a ) check_equivalence(_a , _a , _a ) a__: str =self._prepare_for_class(_a , _a , return_labels=_a ) a__: Any =self._prepare_for_class(_a , _a , return_labels=_a ) check_equivalence(_a , _a , _a ) a__: Any =self._prepare_for_class(_a , _a ) a__: List[Any] =self._prepare_for_class(_a , _a ) check_equivalence(_a , _a , _a , {"output_hidden_states": True} ) a__: Any =self._prepare_for_class(_a , _a , return_labels=_a ) a__: str =self._prepare_for_class(_a , _a , return_labels=_a ) check_equivalence(_a , _a , _a , {"output_hidden_states": True} ) @require_torch class lowerCamelCase__ ( unittest.TestCase , _a ): _lowerCAmelCase = (MaskFormerSwinBackbone,) if is_torch_available() else () _lowerCAmelCase = MaskFormerSwinConfig def _lowerCamelCase ( self : List[Any] ): a__: str =MaskFormerSwinModelTester(self ) def _lowerCamelCase ( self : str ): a__ , a__: int =self.model_tester.prepare_config_and_inputs_for_common() a__: Dict =inputs_dict["pixel_values"].shape[0] for backbone_class in self.all_model_classes: a__: Any =backbone_class(_a ) backbone.to(_a ) backbone.eval() a__: Dict =backbone(**_a ) # Test default outputs and verify feature maps self.assertIsInstance(outputs.feature_maps , _a ) self.assertTrue(len(outputs.feature_maps ) == len(backbone.channels ) ) for feature_map, n_channels in zip(outputs.feature_maps , backbone.channels ): self.assertTrue(feature_map.shape[:2] , (batch_size, n_channels) ) self.assertIsNone(outputs.hidden_states ) self.assertIsNone(outputs.attentions ) # Test output_hidden_states=True a__: Union[str, Any] =backbone(**_a , output_hidden_states=_a ) self.assertIsNotNone(outputs.hidden_states ) self.assertTrue(len(outputs.hidden_states ) , len(backbone.stage_names ) ) # We skip the stem layer for hidden_states, n_channels in zip(outputs.hidden_states[1:] , backbone.channels ): for hidden_state in hidden_states: # Hidden states are in the format (batch_size, (height * width), n_channels) a__ , a__ , a__: Dict =hidden_state.shape self.assertTrue((h_batch_size, h_n_channels) , (batch_size, n_channels) ) # Test output_attentions=True if self.has_attentions: a__: Dict =backbone(**_a , output_attentions=_a ) self.assertIsNotNone(outputs.attentions )

from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available __UpperCAmelCase = { '''configuration_blip_2''': [ '''BLIP_2_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''Blip2Config''', '''Blip2QFormerConfig''', '''Blip2VisionConfig''', ], '''processing_blip_2''': ['''Blip2Processor'''], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ '''BLIP_2_PRETRAINED_MODEL_ARCHIVE_LIST''', '''Blip2Model''', '''Blip2QFormerModel''', '''Blip2PreTrainedModel''', '''Blip2ForConditionalGeneration''', '''Blip2VisionModel''', ] if TYPE_CHECKING: from .configuration_blip_a import ( BLIP_2_PRETRAINED_CONFIG_ARCHIVE_MAP, BlipaConfig, BlipaQFormerConfig, BlipaVisionConfig, ) from .processing_blip_a import BlipaProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_blip_a import ( BLIP_2_PRETRAINED_MODEL_ARCHIVE_LIST, BlipaForConditionalGeneration, BlipaModel, BlipaPreTrainedModel, BlipaQFormerModel, BlipaVisionModel, ) else: import sys __UpperCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

import sys from .dependency_versions_table import deps from .utils.versions import require_version, require_version_core # define which module versions we always want to check at run time # (usually the ones defined in `install_requires` in setup.py) # # order specific notes: # - tqdm must be checked before tokenizers __A : int = "python tqdm regex requests packaging filelock numpy tokenizers".split() if sys.version_info < (3, 7): pkgs_to_check_at_runtime.append("dataclasses") if sys.version_info < (3, 8): pkgs_to_check_at_runtime.append("importlib_metadata") for pkg in pkgs_to_check_at_runtime: if pkg in deps: if pkg == "tokenizers": # must be loaded here, or else tqdm check may fail from .utils import is_tokenizers_available if not is_tokenizers_available(): continue # not required, check version only if installed require_version_core(deps[pkg]) else: raise ValueError(F'can\'t find {pkg} in {deps.keys()}, check dependency_versions_table.py') def __SCREAMING_SNAKE_CASE ( UpperCamelCase__ , UpperCamelCase__=None ) -> List[str]: '''simple docstring''' require_version(deps[pkg] , UpperCamelCase__ )

'''simple docstring''' import copy from ...configuration_utils import PretrainedConfig from ...utils import logging from ..auto.configuration_auto import CONFIG_MAPPING _SCREAMING_SNAKE_CASE : Optional[int] = logging.get_logger(__name__) class _snake_case ( lowercase_ ): lowerCAmelCase_ : Any = "upernet" def __init__( self , a__=None , a__=512 , a__=0.0_2 , a__=[1, 2, 3, 6] , a__=True , a__=0.4 , a__=384 , a__=256 , a__=1 , a__=False , a__=255 , **a__ , ) -> Union[str, Any]: '''simple docstring''' super().__init__(**a__ ) if backbone_config is None: logger.info("`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone." ) snake_case_ = CONFIG_MAPPING["resnet"](out_features=["stage1", "stage2", "stage3", "stage4"] ) elif isinstance(a__ , a__ ): snake_case_ = backbone_config.get("model_type" ) snake_case_ = CONFIG_MAPPING[backbone_model_type] snake_case_ = config_class.from_dict(a__ ) snake_case_ = backbone_config snake_case_ = hidden_size snake_case_ = initializer_range snake_case_ = pool_scales snake_case_ = use_auxiliary_head snake_case_ = auxiliary_loss_weight snake_case_ = auxiliary_in_channels snake_case_ = auxiliary_channels snake_case_ = auxiliary_num_convs snake_case_ = auxiliary_concat_input snake_case_ = loss_ignore_index def lowerCAmelCase__ ( self ) -> Optional[Any]: '''simple docstring''' snake_case_ = copy.deepcopy(self.__dict__ ) snake_case_ = self.backbone_config.to_dict() snake_case_ = self.__class__.model_type return output

'''simple docstring''' from string import ascii_uppercase lowercase ={str(ord(c) - 55): c for c in ascii_uppercase} def lowerCamelCase__ ( __lowerCamelCase : int , __lowerCamelCase : int ): '''simple docstring''' if isinstance(__lowerCamelCase , __lowerCamelCase ): raise TypeError('int() can\'t convert non-string with explicit base' ) if num < 0: raise ValueError('parameter must be positive int' ) if isinstance(__lowerCamelCase , __lowerCamelCase ): raise TypeError('\'str\' object cannot be interpreted as an integer' ) if isinstance(__lowerCamelCase , __lowerCamelCase ): raise TypeError('\'float\' object cannot be interpreted as an integer' ) if base in (0, 1): raise ValueError('base must be >= 2' ) if base > 3_6: raise ValueError('base must be <= 36' ) _UpperCAmelCase : Union[str, Any] ='' _UpperCAmelCase : Optional[int] =0 _UpperCAmelCase : str =0 while div != 1: _UpperCAmelCase , _UpperCAmelCase : int =divmod(__lowerCamelCase , __lowerCamelCase ) if base >= 1_1 and 9 < mod < 3_6: _UpperCAmelCase : str =ALPHABET_VALUES[str(__lowerCamelCase )] else: _UpperCAmelCase : Any =str(__lowerCamelCase ) new_value += actual_value _UpperCAmelCase : Union[str, Any] =num // base _UpperCAmelCase : Dict =div if div == 0: return str(new_value[::-1] ) elif div == 1: new_value += str(__lowerCamelCase ) return str(new_value[::-1] ) return new_value[::-1] if __name__ == "__main__": import doctest doctest.testmod() for base in range(2, 37): for num in range(1000): assert int(decimal_to_any(num, base), base) == num, ( num, base, decimal_to_any(num, base), int(decimal_to_any(num, base), base), )

'''simple docstring''' from typing import Any def lowerCamelCase__ ( __lowerCamelCase : list , __lowerCamelCase : list , __lowerCamelCase : dict , __lowerCamelCase : dict , __lowerCamelCase : dict , ): '''simple docstring''' _validation( __lowerCamelCase , __lowerCamelCase , __lowerCamelCase , __lowerCamelCase , __lowerCamelCase , ) # Creates data structures and fill initial step _UpperCAmelCase : dict ={} _UpperCAmelCase : dict ={} for state in states_space: _UpperCAmelCase : int =observations_space[0] _UpperCAmelCase : int =( initial_probabilities[state] * emission_probabilities[state][observation] ) _UpperCAmelCase : int =None # Fills the data structure with the probabilities of # different transitions and pointers to previous states for o in range(1 , len(__lowerCamelCase ) ): _UpperCAmelCase : List[Any] =observations_space[o] _UpperCAmelCase : Optional[int] =observations_space[o - 1] for state in states_space: # Calculates the argmax for probability function _UpperCAmelCase : List[str] ='' _UpperCAmelCase : Dict =-1 for k_state in states_space: _UpperCAmelCase : List[str] =( probabilities[(k_state, prior_observation)] * transition_probabilities[k_state][state] * emission_probabilities[state][observation] ) if probability > max_probability: _UpperCAmelCase : int =probability _UpperCAmelCase : List[Any] =k_state # Update probabilities and pointers dicts _UpperCAmelCase : str =( probabilities[(arg_max, prior_observation)] * transition_probabilities[arg_max][state] * emission_probabilities[state][observation] ) _UpperCAmelCase : List[Any] =arg_max # The final observation _UpperCAmelCase : int =observations_space[len(__lowerCamelCase ) - 1] # argmax for given final observation _UpperCAmelCase : Any ='' _UpperCAmelCase : Union[str, Any] =-1 for k_state in states_space: _UpperCAmelCase : Optional[int] =probabilities[(k_state, final_observation)] if probability > max_probability: _UpperCAmelCase : Union[str, Any] =probability _UpperCAmelCase : int =k_state _UpperCAmelCase : int =arg_max # Process pointers backwards _UpperCAmelCase : List[str] =last_state _UpperCAmelCase : Optional[int] =[] for o in range(len(__lowerCamelCase ) - 1 , -1 , -1 ): result.append(__lowerCamelCase ) _UpperCAmelCase : Optional[Any] =pointers[previous, observations_space[o]] result.reverse() return result def lowerCamelCase__ ( __lowerCamelCase : Any , __lowerCamelCase : Any , __lowerCamelCase : Any , __lowerCamelCase : Any , __lowerCamelCase : Any , ): '''simple docstring''' _validate_not_empty( __lowerCamelCase , __lowerCamelCase , __lowerCamelCase , __lowerCamelCase , __lowerCamelCase , ) _validate_lists(__lowerCamelCase , __lowerCamelCase ) _validate_dicts( __lowerCamelCase , __lowerCamelCase , __lowerCamelCase ) def lowerCamelCase__ ( __lowerCamelCase : Any , __lowerCamelCase : Any , __lowerCamelCase : Any , __lowerCamelCase : Any , __lowerCamelCase : Any , ): '''simple docstring''' if not all( [ observations_space, states_space, initial_probabilities, transition_probabilities, emission_probabilities, ] ): raise ValueError('There\'s an empty parameter' ) def lowerCamelCase__ ( __lowerCamelCase : Any , __lowerCamelCase : Any ): '''simple docstring''' _validate_list(__lowerCamelCase , 'observations_space' ) _validate_list(__lowerCamelCase , 'states_space' ) def lowerCamelCase__ ( __lowerCamelCase : Any , __lowerCamelCase : str ): '''simple docstring''' if not isinstance(_object , __lowerCamelCase ): _UpperCAmelCase : Any =f"{var_name} must be a list" raise ValueError(__lowerCamelCase ) else: for x in _object: if not isinstance(__lowerCamelCase , __lowerCamelCase ): _UpperCAmelCase : Optional[int] =f"{var_name} must be a list of strings" raise ValueError(__lowerCamelCase ) def lowerCamelCase__ ( __lowerCamelCase : Any , __lowerCamelCase : Any , __lowerCamelCase : Any , ): '''simple docstring''' _validate_dict(__lowerCamelCase , 'initial_probabilities' , __lowerCamelCase ) _validate_nested_dict(__lowerCamelCase , 'transition_probabilities' ) _validate_nested_dict(__lowerCamelCase , 'emission_probabilities' ) def lowerCamelCase__ ( __lowerCamelCase : Any , __lowerCamelCase : str ): '''simple docstring''' _validate_dict(_object , __lowerCamelCase , __lowerCamelCase ) for x in _object.values(): _validate_dict(__lowerCamelCase , __lowerCamelCase , __lowerCamelCase , __lowerCamelCase ) def lowerCamelCase__ ( __lowerCamelCase : Any , __lowerCamelCase : str , __lowerCamelCase : type , __lowerCamelCase : bool = False ): '''simple docstring''' if not isinstance(_object , __lowerCamelCase ): _UpperCAmelCase : List[str] =f"{var_name} must be a dict" raise ValueError(__lowerCamelCase ) if not all(isinstance(__lowerCamelCase , __lowerCamelCase ) for x in _object ): _UpperCAmelCase : str =f"{var_name} all keys must be strings" raise ValueError(__lowerCamelCase ) if not all(isinstance(__lowerCamelCase , __lowerCamelCase ) for x in _object.values() ): _UpperCAmelCase : int ='nested dictionary ' if nested else '' _UpperCAmelCase : Optional[int] =f"{var_name} {nested_text}all values must be {value_type.__name__}" raise ValueError(__lowerCamelCase ) if __name__ == "__main__": from doctest import testmod testmod()

import collections import tempfile import unittest import numpy as np from transformers.testing_utils import ( is_pt_flax_cross_test, require_flax, require_torch, require_vision, slow, torch_device, ) from transformers.utils import is_flax_available, is_torch_available, is_vision_available from ...test_modeling_flax_common import floats_tensor, ids_tensor, random_attention_mask from ..bert.test_modeling_flax_bert import FlaxBertModelTester from ..clip.test_modeling_flax_clip import FlaxCLIPVisionModelTester from ..vit.test_modeling_flax_vit import FlaxViTModelTester if is_flax_available(): from transformers import ( FlaxBertModel, FlaxCLIPVisionModel, FlaxVisionTextDualEncoderModel, FlaxViTModel, VisionTextDualEncoderConfig, VisionTextDualEncoderProcessor, ) from transformers.modeling_flax_pytorch_utils import ( convert_pytorch_state_dict_to_flax, load_flax_weights_in_pytorch_model, ) if is_torch_available(): import torch from transformers import VisionTextDualEncoderModel if is_vision_available(): from PIL import Image def A ( _SCREAMING_SNAKE_CASE ) -> List[Any]: if isinstance(_SCREAMING_SNAKE_CASE ,collections.abc.Iterable ): return x return (x, x) @require_flax class UpperCamelCase__ : '''simple docstring''' def _lowercase ( self , UpperCamelCase__ , UpperCamelCase__ ) -> List[str]: pass def _lowercase ( self ) -> Any: pass def _lowercase ( self ) -> Optional[Any]: pass def _lowercase ( self , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) -> int: lowerCamelCase : Union[str, Any] = np.abs((a - b) ).max() self.assertLessEqual(UpperCamelCase__ , UpperCamelCase__ , F'''Difference between torch and flax is {diff} (>= {tol}).''' ) def _lowercase ( self , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__=None , **UpperCamelCase__ ) -> int: lowerCamelCase : Tuple = VisionTextDualEncoderConfig.from_vision_text_configs(UpperCamelCase__ , UpperCamelCase__ ) lowerCamelCase : int = FlaxVisionTextDualEncoderModel(UpperCamelCase__ ) lowerCamelCase : Any = model(input_ids=UpperCamelCase__ , pixel_values=UpperCamelCase__ , attention_mask=UpperCamelCase__ ) self.assertEqual(output["text_embeds"].shape , (input_ids.shape[0], config.projection_dim) ) self.assertEqual(output["image_embeds"].shape , (pixel_values.shape[0], config.projection_dim) ) def _lowercase ( self , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__=None , **UpperCamelCase__ ) -> Tuple: lowerCamelCase , lowerCamelCase : Optional[int] = self.get_vision_text_model(UpperCamelCase__ , UpperCamelCase__ ) lowerCamelCase : List[str] = {"vision_model": vision_model, "text_model": text_model} lowerCamelCase : Tuple = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**UpperCamelCase__ ) lowerCamelCase : Any = model(input_ids=UpperCamelCase__ , pixel_values=UpperCamelCase__ , attention_mask=UpperCamelCase__ ) self.assertEqual(output["text_embeds"].shape , (input_ids.shape[0], model.config.projection_dim) ) self.assertEqual(output["image_embeds"].shape , (pixel_values.shape[0], model.config.projection_dim) ) def _lowercase ( self , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__=None , **UpperCamelCase__ ) -> Tuple: lowerCamelCase , lowerCamelCase : str = self.get_vision_text_model(UpperCamelCase__ , UpperCamelCase__ ) lowerCamelCase : Union[str, Any] = {"vision_model": vision_model, "text_model": text_model} lowerCamelCase : Union[str, Any] = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**UpperCamelCase__ ) lowerCamelCase : Union[str, Any] = model(input_ids=UpperCamelCase__ , pixel_values=UpperCamelCase__ , attention_mask=UpperCamelCase__ ) lowerCamelCase : int = output[0] with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(UpperCamelCase__ ) lowerCamelCase : List[str] = FlaxVisionTextDualEncoderModel.from_pretrained(UpperCamelCase__ ) lowerCamelCase : int = model(input_ids=UpperCamelCase__ , pixel_values=UpperCamelCase__ , attention_mask=UpperCamelCase__ ) lowerCamelCase : int = after_output[0] lowerCamelCase : Optional[Any] = np.amax(np.abs(out_a - out_a ) ) self.assertLessEqual(UpperCamelCase__ , 1e-3 ) def _lowercase ( self , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__=None , **UpperCamelCase__ ) -> Union[str, Any]: lowerCamelCase , lowerCamelCase : Dict = self.get_vision_text_model(UpperCamelCase__ , UpperCamelCase__ ) lowerCamelCase : Dict = {"vision_model": vision_model, "text_model": text_model} lowerCamelCase : Tuple = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**UpperCamelCase__ ) lowerCamelCase : Union[str, Any] = model( input_ids=UpperCamelCase__ , pixel_values=UpperCamelCase__ , attention_mask=UpperCamelCase__ , output_attentions=UpperCamelCase__ ) lowerCamelCase : Tuple = output.vision_model_output.attentions self.assertEqual(len(UpperCamelCase__ ) , vision_config.num_hidden_layers ) # in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token) lowerCamelCase : Tuple = to_atuple(vision_model.config.image_size ) lowerCamelCase : str = to_atuple(vision_model.config.patch_size ) lowerCamelCase : List[Any] = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0]) lowerCamelCase : Union[str, Any] = num_patches + 1 self.assertEqual(vision_attentions[0].shape[-3:] , (vision_config.num_attention_heads, seq_len, seq_len) ) lowerCamelCase : Optional[Any] = output.text_model_output.attentions self.assertEqual(len(UpperCamelCase__ ) , text_config.num_hidden_layers ) self.assertEqual( text_attentions[0].shape[-3:] , (text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1]) , ) def _lowercase ( self , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) -> Tuple: pt_model.to(UpperCamelCase__ ) pt_model.eval() # prepare inputs lowerCamelCase : int = inputs_dict lowerCamelCase : Any = {k: torch.tensor(v.tolist() ) for k, v in flax_inputs.items()} with torch.no_grad(): lowerCamelCase : int = pt_model(**UpperCamelCase__ ).to_tuple() lowerCamelCase : Any = fx_model(**UpperCamelCase__ ).to_tuple() self.assertEqual(len(UpperCamelCase__ ) , len(UpperCamelCase__ ) , "Output lengths differ between Flax and PyTorch" ) for fx_output, pt_output in zip(fx_outputs[:4] , pt_outputs[:4] ): self.assert_almost_equals(UpperCamelCase__ , pt_output.numpy() , 4e-2 ) # PT -> Flax with tempfile.TemporaryDirectory() as tmpdirname: pt_model.save_pretrained(UpperCamelCase__ ) lowerCamelCase : List[str] = FlaxVisionTextDualEncoderModel.from_pretrained(UpperCamelCase__ , from_pt=UpperCamelCase__ ) lowerCamelCase : Tuple = fx_model_loaded(**UpperCamelCase__ ).to_tuple() self.assertEqual(len(UpperCamelCase__ ) , len(UpperCamelCase__ ) , "Output lengths differ between Flax and PyTorch" ) for fx_output_loaded, pt_output in zip(fx_outputs_loaded[:4] , pt_outputs[:4] ): self.assert_almost_equals(UpperCamelCase__ , pt_output.numpy() , 4e-2 ) # Flax -> PT with tempfile.TemporaryDirectory() as tmpdirname: fx_model.save_pretrained(UpperCamelCase__ ) lowerCamelCase : Any = VisionTextDualEncoderModel.from_pretrained(UpperCamelCase__ , from_flax=UpperCamelCase__ ) pt_model_loaded.to(UpperCamelCase__ ) pt_model_loaded.eval() with torch.no_grad(): lowerCamelCase : List[str] = pt_model_loaded(**UpperCamelCase__ ).to_tuple() self.assertEqual(len(UpperCamelCase__ ) , len(UpperCamelCase__ ) , "Output lengths differ between Flax and PyTorch" ) for fx_output, pt_output_loaded in zip(fx_outputs[:4] , pt_outputs_loaded[:4] ): self.assert_almost_equals(UpperCamelCase__ , pt_output_loaded.numpy() , 4e-2 ) def _lowercase ( self , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) -> List[str]: lowerCamelCase : Optional[Any] = VisionTextDualEncoderConfig.from_vision_text_configs(UpperCamelCase__ , UpperCamelCase__ ) lowerCamelCase : str = VisionTextDualEncoderModel(UpperCamelCase__ ) lowerCamelCase : List[str] = FlaxVisionTextDualEncoderModel(UpperCamelCase__ ) lowerCamelCase : Optional[int] = convert_pytorch_state_dict_to_flax(pt_model.state_dict() , UpperCamelCase__ ) lowerCamelCase : List[Any] = fx_state self.check_pt_flax_equivalence(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) def _lowercase ( self , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) -> Optional[int]: lowerCamelCase : Any = VisionTextDualEncoderConfig.from_vision_text_configs(UpperCamelCase__ , UpperCamelCase__ ) lowerCamelCase : int = VisionTextDualEncoderModel(UpperCamelCase__ ) lowerCamelCase : Optional[int] = FlaxVisionTextDualEncoderModel(UpperCamelCase__ ) lowerCamelCase : Any = load_flax_weights_in_pytorch_model(UpperCamelCase__ , fx_model.params ) self.check_pt_flax_equivalence(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) def _lowercase ( self ) -> Optional[Any]: lowerCamelCase : Optional[Any] = self.prepare_config_and_inputs() self.check_model_from_pretrained_configs(**UpperCamelCase__ ) def _lowercase ( self ) -> int: lowerCamelCase : Any = self.prepare_config_and_inputs() self.check_vision_text_dual_encoder_from_pretrained(**UpperCamelCase__ ) def _lowercase ( self ) -> List[Any]: lowerCamelCase : List[str] = self.prepare_config_and_inputs() self.check_save_load(**UpperCamelCase__ ) def _lowercase ( self ) -> Dict: lowerCamelCase : Any = self.prepare_config_and_inputs() self.check_vision_text_output_attention(**UpperCamelCase__ ) @is_pt_flax_cross_test def _lowercase ( self ) -> Optional[Any]: lowerCamelCase : int = self.prepare_config_and_inputs() lowerCamelCase : Union[str, Any] = config_inputs_dict.pop("vision_config" ) lowerCamelCase : Tuple = config_inputs_dict.pop("text_config" ) lowerCamelCase : Dict = config_inputs_dict self.check_equivalence_pt_to_flax(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) self.check_equivalence_flax_to_pt(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) @slow def _lowercase ( self ) -> Optional[int]: lowerCamelCase , lowerCamelCase : List[Any] = self.get_pretrained_model_and_inputs() lowerCamelCase : Any = model_a(**UpperCamelCase__ ) lowerCamelCase : Any = outputs[0] with tempfile.TemporaryDirectory() as tmp_dirname: model_a.save_pretrained(UpperCamelCase__ ) lowerCamelCase : Optional[int] = FlaxVisionTextDualEncoderModel.from_pretrained(UpperCamelCase__ ) lowerCamelCase : int = model_a(**UpperCamelCase__ ) lowerCamelCase : List[str] = after_outputs[0] lowerCamelCase : Tuple = np.amax(np.abs(out_a - out_a ) ) self.assertLessEqual(UpperCamelCase__ , 1e-5 ) @require_flax class UpperCamelCase__ (lowerCAmelCase__ , unittest.TestCase ): '''simple docstring''' def _lowercase ( self ) -> int: lowerCamelCase : List[Any] = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained( "hf-internal-testing/tiny-random-vit" , "hf-internal-testing/tiny-bert" , vision_from_pt=UpperCamelCase__ , text_from_pt=UpperCamelCase__ , ) lowerCamelCase : str = 13 lowerCamelCase : List[str] = floats_tensor( [ batch_size, model.config.vision_config.num_channels, model.config.vision_config.image_size, model.config.vision_config.image_size, ] ) lowerCamelCase : Dict = ids_tensor([batch_size, 4] , model.config.text_config.vocab_size ) lowerCamelCase : Dict = random_attention_mask([batch_size, 4] ) lowerCamelCase : Optional[int] = {"pixel_values": pixel_values, "input_ids": input_ids, "attention_mask": attention_mask} return model, inputs def _lowercase ( self , UpperCamelCase__ , UpperCamelCase__ ) -> Union[str, Any]: lowerCamelCase : Dict = FlaxViTModel(UpperCamelCase__ ) lowerCamelCase : Union[str, Any] = FlaxBertModel(UpperCamelCase__ ) return vision_model, text_model def _lowercase ( self ) -> List[Any]: lowerCamelCase : Optional[int] = FlaxViTModelTester(self ) lowerCamelCase : Any = FlaxBertModelTester(self ) lowerCamelCase : Union[str, Any] = vit_model_tester.prepare_config_and_inputs() lowerCamelCase : str = bert_model_tester.prepare_config_and_inputs() lowerCamelCase , lowerCamelCase : Optional[int] = vision_config_and_inputs lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase : Any = text_config_and_inputs # make sure that cross attention layers are added return { "text_config": text_config, "vision_config": vision_config, "pixel_values": pixel_values, "attention_mask": attention_mask, "input_ids": input_ids, "token_type_ids": token_type_ids, } @require_torch class UpperCamelCase__ (lowerCAmelCase__ , unittest.TestCase ): '''simple docstring''' def _lowercase ( self ) -> Tuple: lowerCamelCase : Optional[int] = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained( "hf-internal-testing/tiny-random-clip" , "hf-internal-testing/tiny-bert" , vision_from_pt=UpperCamelCase__ , text_from_pt=UpperCamelCase__ , ) lowerCamelCase : Optional[int] = 13 lowerCamelCase : List[str] = floats_tensor( [ batch_size, model.config.vision_config.num_channels, model.config.vision_config.image_size, model.config.vision_config.image_size, ] ) lowerCamelCase : Tuple = ids_tensor([batch_size, 4] , model.config.text_config.vocab_size ) lowerCamelCase : Union[str, Any] = random_attention_mask([batch_size, 4] ) lowerCamelCase : Optional[int] = {"pixel_values": pixel_values, "input_ids": input_ids, "attention_mask": attention_mask} return model, inputs def _lowercase ( self , UpperCamelCase__ , UpperCamelCase__ ) -> str: lowerCamelCase : List[Any] = FlaxCLIPVisionModel(UpperCamelCase__ ) lowerCamelCase : Dict = FlaxBertModel(UpperCamelCase__ ) return vision_model, text_model def _lowercase ( self ) -> Dict: lowerCamelCase : Optional[Any] = FlaxCLIPVisionModelTester(self ) lowerCamelCase : Optional[int] = FlaxBertModelTester(self ) lowerCamelCase : List[Any] = clip_model_tester.prepare_config_and_inputs() lowerCamelCase : int = bert_model_tester.prepare_config_and_inputs() lowerCamelCase , lowerCamelCase : Any = vision_config_and_inputs lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase : int = text_config_and_inputs # make sure that cross attention layers are added return { "text_config": text_config, "vision_config": vision_config, "pixel_values": pixel_values, "attention_mask": attention_mask, "input_ids": input_ids, "token_type_ids": token_type_ids, } @require_flax @require_vision class UpperCamelCase__ (unittest.TestCase ): '''simple docstring''' @slow def _lowercase ( self ) -> Union[str, Any]: lowerCamelCase : Tuple = FlaxVisionTextDualEncoderModel.from_pretrained("clip-italian/clip-italian" , logit_scale_init_value=1.0 ) lowerCamelCase : Optional[int] = VisionTextDualEncoderProcessor.from_pretrained("clip-italian/clip-italian" ) lowerCamelCase : Optional[Any] = Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png" ) lowerCamelCase : Optional[int] = processor( text=["una foto di un gatto", "una foto di un cane"] , images=UpperCamelCase__ , padding=UpperCamelCase__ , return_tensors="np" ) lowerCamelCase : Dict = model(**UpperCamelCase__ ) # verify the logits self.assertEqual(outputs.logits_per_image.shape , (inputs.pixel_values.shape[0], inputs.input_ids.shape[0]) ) self.assertEqual( outputs.logits_per_text.shape , (inputs.input_ids.shape[0], inputs.pixel_values.shape[0]) , ) lowerCamelCase : Dict = np.array([[1.2284727, 0.3104122]] ) self.assertTrue(np.allclose(outputs.logits_per_image , UpperCamelCase__ , atol=1e-3 ) )

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 __lowerCamelCase : Any = 16 __lowerCamelCase : List[Any] = 32 def __SCREAMING_SNAKE_CASE ( __UpperCamelCase : Accelerator , __UpperCamelCase : int = 16 , __UpperCamelCase : str = "bert-base-cased" ) -> str: """simple docstring""" SCREAMING_SNAKE_CASE__ = AutoTokenizer.from_pretrained(__UpperCamelCase ) SCREAMING_SNAKE_CASE__ = load_dataset("""glue""" , """mrpc""" ) def tokenize_function(__UpperCamelCase : Optional[Any] ): # max_length=None => use the model max length (it's actually the default) SCREAMING_SNAKE_CASE__ = tokenizer(examples["""sentence1"""] , examples["""sentence2"""] , truncation=__UpperCamelCase , max_length=__UpperCamelCase ) return outputs # Apply the method we just defined to all the examples in all the splits of the dataset SCREAMING_SNAKE_CASE__ = datasets.map( __UpperCamelCase , batched=__UpperCamelCase , remove_columns=["""idx""", """sentence1""", """sentence2"""] , load_from_cache_file=__UpperCamelCase ) # 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__ = tokenized_datasets.rename_column("""label""" , """labels""" ) def collate_fn(__UpperCamelCase : List[Any] ): # 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(__UpperCamelCase , padding="""max_length""" , max_length=1_28 , return_tensors="""pt""" ) return tokenizer.pad(__UpperCamelCase , padding="""longest""" , return_tensors="""pt""" ) # Instantiate dataloaders. SCREAMING_SNAKE_CASE__ = DataLoader( tokenized_datasets["""train"""] , shuffle=__UpperCamelCase , collate_fn=__UpperCamelCase , batch_size=__UpperCamelCase ) SCREAMING_SNAKE_CASE__ = DataLoader( tokenized_datasets["""validation"""] , shuffle=__UpperCamelCase , collate_fn=__UpperCamelCase , batch_size=__UpperCamelCase ) return train_dataloader, eval_dataloader def __SCREAMING_SNAKE_CASE ( __UpperCamelCase : Optional[Any] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Optional[int] ) -> List[str]: """simple docstring""" model.eval() SCREAMING_SNAKE_CASE__ = 0 for step, batch in enumerate(__UpperCamelCase ): # 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__ = model(**__UpperCamelCase ) SCREAMING_SNAKE_CASE__ = outputs.logits.argmax(dim=-1 ) # It is slightly faster to call this once, than multiple times SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ = accelerator.gather( (predictions, batch["""labels"""]) ) # If we are in a multiprocess environment, the last batch has duplicates if accelerator.use_distributed: if step == len(__UpperCamelCase ) - 1: SCREAMING_SNAKE_CASE__ = predictions[: len(eval_dataloader.dataset ) - samples_seen] SCREAMING_SNAKE_CASE__ = references[: len(eval_dataloader.dataset ) - samples_seen] else: samples_seen += references.shape[0] metric.add_batch( predictions=__UpperCamelCase , references=__UpperCamelCase , ) SCREAMING_SNAKE_CASE__ = metric.compute() return eval_metric["accuracy"] def __SCREAMING_SNAKE_CASE ( __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Any ) -> Tuple: """simple docstring""" SCREAMING_SNAKE_CASE__ = Accelerator() # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs SCREAMING_SNAKE_CASE__ = config["""lr"""] SCREAMING_SNAKE_CASE__ = int(config["""num_epochs"""] ) SCREAMING_SNAKE_CASE__ = int(config["""seed"""] ) SCREAMING_SNAKE_CASE__ = int(config["""batch_size"""] ) SCREAMING_SNAKE_CASE__ = args.model_name_or_path set_seed(__UpperCamelCase ) SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ = get_dataloaders(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) # Instantiate the model (we build the model here so that the seed also control new weights initialization) SCREAMING_SNAKE_CASE__ = AutoModelForSequenceClassification.from_pretrained(__UpperCamelCase , return_dict=__UpperCamelCase ) # Instantiate optimizer SCREAMING_SNAKE_CASE__ = ( AdamW if accelerator.state.deepspeed_plugin is None or """optimizer""" not in accelerator.state.deepspeed_plugin.deepspeed_config else DummyOptim ) SCREAMING_SNAKE_CASE__ = optimizer_cls(params=model.parameters() , lr=__UpperCamelCase ) if accelerator.state.deepspeed_plugin is not None: SCREAMING_SNAKE_CASE__ = accelerator.state.deepspeed_plugin.deepspeed_config[ """gradient_accumulation_steps""" ] else: SCREAMING_SNAKE_CASE__ = 1 SCREAMING_SNAKE_CASE__ = (len(__UpperCamelCase ) * 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__ = get_linear_schedule_with_warmup( optimizer=__UpperCamelCase , num_warmup_steps=0 , num_training_steps=__UpperCamelCase , ) else: SCREAMING_SNAKE_CASE__ = DummyScheduler(__UpperCamelCase , total_num_steps=__UpperCamelCase , 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__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ = accelerator.prepare( __UpperCamelCase , __UpperCamelCase , __UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) # We need to keep track of how many total steps we have iterated over SCREAMING_SNAKE_CASE__ = 0 # We also need to keep track of the stating epoch so files are named properly SCREAMING_SNAKE_CASE__ = 0 SCREAMING_SNAKE_CASE__ = evaluate.load("""glue""" , """mrpc""" ) SCREAMING_SNAKE_CASE__ = num_epochs if args.partial_train_epoch is not None: SCREAMING_SNAKE_CASE__ = args.partial_train_epoch if args.resume_from_checkpoint: accelerator.load_state(args.resume_from_checkpoint ) SCREAMING_SNAKE_CASE__ = args.resume_from_checkpoint.split("""epoch_""" )[1] SCREAMING_SNAKE_CASE__ = """""" for char in epoch_string: if char.isdigit(): state_epoch_num += char else: break SCREAMING_SNAKE_CASE__ = int(__UpperCamelCase ) + 1 SCREAMING_SNAKE_CASE__ = evaluation_loop(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) accelerator.print("""resumed checkpoint performance:""" , __UpperCamelCase ) 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__ = json.load(__UpperCamelCase ) 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__ = {} for epoch in range(__UpperCamelCase , __UpperCamelCase ): model.train() for step, batch in enumerate(__UpperCamelCase ): SCREAMING_SNAKE_CASE__ = model(**__UpperCamelCase ) SCREAMING_SNAKE_CASE__ = outputs.loss SCREAMING_SNAKE_CASE__ = loss / gradient_accumulation_steps accelerator.backward(__UpperCamelCase ) if step % gradient_accumulation_steps == 0: optimizer.step() lr_scheduler.step() optimizer.zero_grad() overall_step += 1 SCREAMING_SNAKE_CASE__ = f"""epoch_{epoch}""" SCREAMING_SNAKE_CASE__ = os.path.join(args.output_dir , __UpperCamelCase ) accelerator.save_state(__UpperCamelCase ) SCREAMING_SNAKE_CASE__ = evaluation_loop(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) SCREAMING_SNAKE_CASE__ = accuracy SCREAMING_SNAKE_CASE__ = lr_scheduler.get_lr()[0] SCREAMING_SNAKE_CASE__ = optimizer.param_groups[0]["""lr"""] SCREAMING_SNAKE_CASE__ = epoch SCREAMING_SNAKE_CASE__ = overall_step accelerator.print(f"""epoch {epoch}:""" , __UpperCamelCase ) 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(__UpperCamelCase , __UpperCamelCase ) def __SCREAMING_SNAKE_CASE ( ) -> Tuple: """simple docstring""" SCREAMING_SNAKE_CASE__ = argparse.ArgumentParser(description="""Simple example of training script tracking peak GPU memory usage.""" ) parser.add_argument( """--model_name_or_path""" , type=__UpperCamelCase , default="""bert-base-cased""" , help="""Path to pretrained model or model identifier from huggingface.co/models.""" , required=__UpperCamelCase , ) parser.add_argument( """--output_dir""" , type=__UpperCamelCase , 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=__UpperCamelCase , default=__UpperCamelCase , help="""If the training should continue from a checkpoint folder.""" , ) parser.add_argument( """--partial_train_epoch""" , type=__UpperCamelCase , default=__UpperCamelCase , help="""If passed, the training will stop after this number of epochs.""" , ) parser.add_argument( """--num_epochs""" , type=__UpperCamelCase , default=2 , help="""Number of train epochs.""" , ) SCREAMING_SNAKE_CASE__ = parser.parse_args() SCREAMING_SNAKE_CASE__ = {"""lr""": 2E-5, """num_epochs""": args.num_epochs, """seed""": 42, """batch_size""": 16} training_function(__UpperCamelCase , __UpperCamelCase ) if __name__ == "__main__": main()

import argparse import re from typing import Dict import torch from datasets import Audio, Dataset, load_dataset, load_metric from transformers import AutoFeatureExtractor, pipeline def _a ( SCREAMING_SNAKE_CASE_ : Dataset , SCREAMING_SNAKE_CASE_ : Dict[str, str] ): __lowerCAmelCase = args.log_outputs __lowerCAmelCase = "_".join(args.dataset.split("/" ) + [args.config, args.split] ) # load metric __lowerCAmelCase = load_metric("wer" ) __lowerCAmelCase = load_metric("cer" ) # compute metrics __lowerCAmelCase = wer.compute(references=result["target"] , predictions=result["prediction"] ) __lowerCAmelCase = cer.compute(references=result["target"] , predictions=result["prediction"] ) # print & log results __lowerCAmelCase = F"""WER: {wer_result}\nCER: {cer_result}""" print(SCREAMING_SNAKE_CASE_ ) with open(F"""{dataset_id}_eval_results.txt""" , "w" ) as f: f.write(SCREAMING_SNAKE_CASE_ ) # log all results in text file. Possibly interesting for analysis if log_outputs is not None: __lowerCAmelCase = F"""log_{dataset_id}_predictions.txt""" __lowerCAmelCase = F"""log_{dataset_id}_targets.txt""" with open(SCREAMING_SNAKE_CASE_ , "w" ) as p, open(SCREAMING_SNAKE_CASE_ , "w" ) as t: # mapping function to write output def write_to_file(SCREAMING_SNAKE_CASE_ : List[Any] , SCREAMING_SNAKE_CASE_ : Any ): p.write(F"""{i}""" + "\n" ) p.write(batch["prediction"] + "\n" ) t.write(F"""{i}""" + "\n" ) t.write(batch["target"] + "\n" ) result.map(SCREAMING_SNAKE_CASE_ , with_indices=SCREAMING_SNAKE_CASE_ ) def _a ( SCREAMING_SNAKE_CASE_ : str ): __lowerCAmelCase = "[,?.!\-\;\:\"“%‘”�—’…–]" # noqa: W605 IMPORTANT: this should correspond to the chars that were ignored during training __lowerCAmelCase = re.sub(SCREAMING_SNAKE_CASE_ , "" , text.lower() ) # In addition, we can normalize the target text, e.g. removing new lines characters etc... # note that order is important here! __lowerCAmelCase = ["\n\n", "\n", " ", " "] for t in token_sequences_to_ignore: __lowerCAmelCase = " ".join(text.split(SCREAMING_SNAKE_CASE_ ) ) return text def _a ( SCREAMING_SNAKE_CASE_ : Optional[int] ): # load dataset __lowerCAmelCase = load_dataset(args.dataset , args.config , split=args.split , use_auth_token=SCREAMING_SNAKE_CASE_ ) # for testing: only process the first two examples as a test # dataset = dataset.select(range(10)) # load processor __lowerCAmelCase = AutoFeatureExtractor.from_pretrained(args.model_id ) __lowerCAmelCase = feature_extractor.sampling_rate # resample audio __lowerCAmelCase = dataset.cast_column("audio" , Audio(sampling_rate=SCREAMING_SNAKE_CASE_ ) ) # load eval pipeline if args.device is None: __lowerCAmelCase = 0 if torch.cuda.is_available() else -1 __lowerCAmelCase = pipeline("automatic-speech-recognition" , model=args.model_id , device=args.device ) # map function to decode audio def map_to_pred(SCREAMING_SNAKE_CASE_ : str ): __lowerCAmelCase = asr( batch["audio"]["array"] , chunk_length_s=args.chunk_length_s , stride_length_s=args.stride_length_s ) __lowerCAmelCase = prediction["text"] __lowerCAmelCase = normalize_text(batch["sentence"] ) return batch # run inference on all examples __lowerCAmelCase = dataset.map(SCREAMING_SNAKE_CASE_ , remove_columns=dataset.column_names ) # compute and log_results # do not change function below log_results(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ) if __name__ == "__main__": UpperCamelCase__ = argparse.ArgumentParser() parser.add_argument( """--model_id""", type=str, required=True, help="""Model identifier. Should be loadable with 🤗 Transformers""" ) parser.add_argument( """--dataset""", type=str, required=True, help="""Dataset name to evaluate the `model_id`. Should be loadable with 🤗 Datasets""", ) parser.add_argument( """--config""", type=str, required=True, help="""Config of the dataset. *E.g.* `'en'` for Common Voice""" ) parser.add_argument("""--split""", type=str, required=True, help="""Split of the dataset. *E.g.* `'test'`""") parser.add_argument( """--chunk_length_s""", type=float, default=None, help="""Chunk length in seconds. Defaults to 5 seconds.""" ) parser.add_argument( """--stride_length_s""", type=float, default=None, help="""Stride of the audio chunks. Defaults to 1 second.""" ) parser.add_argument( """--log_outputs""", action="""store_true""", help="""If defined, write outputs to log file for analysis.""" ) parser.add_argument( """--device""", type=int, default=None, help="""The device to run the pipeline on. -1 for CPU (default), 0 for the first GPU and so on.""", ) UpperCamelCase__ = parser.parse_args() main(args)

from sklearn.metrics import mean_squared_error import datasets UpperCamelCase__ = """\ @article{scikit-learn, title={Scikit-learn: Machine Learning in {P}ython}, author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V. and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P. and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.}, journal={Journal of Machine Learning Research}, volume={12}, pages={2825--2830}, year={2011} } """ UpperCamelCase__ = """\ Mean Squared Error(MSE) is the average of the square of difference between the predicted and actual values. """ UpperCamelCase__ = """ Args: predictions: array-like of shape (n_samples,) or (n_samples, n_outputs) Estimated target values. references: array-like of shape (n_samples,) or (n_samples, n_outputs) Ground truth (correct) target values. sample_weight: array-like of shape (n_samples,), default=None Sample weights. multioutput: {\"raw_values\", \"uniform_average\"} or array-like of shape (n_outputs,), default=\"uniform_average\" Defines aggregating of multiple output values. Array-like value defines weights used to average errors. \"raw_values\" : Returns a full set of errors in case of multioutput input. \"uniform_average\" : Errors of all outputs are averaged with uniform weight. squared : bool, default=True If True returns MSE value, if False returns RMSE (Root Mean Squared Error) value. Returns: mse : mean squared error. Examples: >>> mse_metric = datasets.load_metric(\"mse\") >>> predictions = [2.5, 0.0, 2, 8] >>> references = [3, -0.5, 2, 7] >>> results = mse_metric.compute(predictions=predictions, references=references) >>> print(results) {'mse': 0.375} >>> rmse_result = mse_metric.compute(predictions=predictions, references=references, squared=False) >>> print(rmse_result) {'mse': 0.6123724356957945} If you're using multi-dimensional lists, then set the config as follows : >>> mse_metric = datasets.load_metric(\"mse\", \"multilist\") >>> predictions = [[0.5, 1], [-1, 1], [7, -6]] >>> references = [[0, 2], [-1, 2], [8, -5]] >>> results = mse_metric.compute(predictions=predictions, references=references) >>> print(results) {'mse': 0.7083333333333334} >>> results = mse_metric.compute(predictions=predictions, references=references, multioutput='raw_values') >>> print(results) # doctest: +NORMALIZE_WHITESPACE {'mse': array([0.41666667, 1. ])} """ @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class a__ ( datasets.Metric ): def __SCREAMING_SNAKE_CASE( self ): """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features(self._get_feature_types() ) , reference_urls=[ "https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html" ] , ) def __SCREAMING_SNAKE_CASE( self ): """simple docstring""" if self.config_name == "multilist": return { "predictions": datasets.Sequence(datasets.Value("float" ) ), "references": datasets.Sequence(datasets.Value("float" ) ), } else: return { "predictions": datasets.Value("float" ), "references": datasets.Value("float" ), } def __SCREAMING_SNAKE_CASE( self , _A , _A , _A=None , _A="uniform_average" , _A=True ): """simple docstring""" __lowerCAmelCase = mean_squared_error( _A , _A , sample_weight=_A , multioutput=_A , squared=_A ) return {"mse": mse}

'''simple docstring''' import inspect import os import unittest import torch import accelerate from accelerate import Accelerator from accelerate.test_utils import execute_subprocess_async, require_multi_gpu from accelerate.utils import patch_environment class a_ (unittest.TestCase ): def __UpperCamelCase ( self ): _lowerCAmelCase : Any = inspect.getfile(accelerate.test_utils ) _lowerCAmelCase : Dict = os.path.sep.join(mod_file.split(os.path.sep )[:-1] + ["""scripts""", """test_script.py"""] ) _lowerCAmelCase : Dict = os.path.sep.join( mod_file.split(os.path.sep )[:-1] + ["""scripts""", """test_distributed_data_loop.py"""] ) _lowerCAmelCase : List[str] = os.path.sep.join(mod_file.split(os.path.sep )[:-1] + ["""scripts""", """test_ops.py"""] ) @require_multi_gpu def __UpperCamelCase ( self ): print(f'Found {torch.cuda.device_count()} devices.' ) _lowerCAmelCase : Tuple = ["""torchrun""", f'--nproc_per_node={torch.cuda.device_count()}', self.test_file_path] with patch_environment(omp_num_threads=1 ): execute_subprocess_async(snake_case_ , env=os.environ.copy() ) @require_multi_gpu def __UpperCamelCase ( self ): print(f'Found {torch.cuda.device_count()} devices.' ) _lowerCAmelCase : str = ["""torchrun""", f'--nproc_per_node={torch.cuda.device_count()}', self.operation_file_path] print(f'Command: {cmd}' ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(snake_case_ , env=os.environ.copy() ) @require_multi_gpu def __UpperCamelCase ( self ): _lowerCAmelCase : Tuple = ["""torchrun""", f'--nproc_per_node={torch.cuda.device_count()}', inspect.getfile(self.__class__ )] with patch_environment(omp_num_threads=1 ): execute_subprocess_async(snake_case_ , env=os.environ.copy() ) @require_multi_gpu def __UpperCamelCase ( self ): print(f'Found {torch.cuda.device_count()} devices, using 2 devices only' ) _lowerCAmelCase : Any = ["""torchrun""", f'--nproc_per_node={torch.cuda.device_count()}', self.data_loop_file_path] with patch_environment(omp_num_threads=1 , cuda_visible_devices="""0,1""" ): execute_subprocess_async(snake_case_ , env=os.environ.copy() ) if __name__ == "__main__": UpperCamelCase_ = Accelerator() UpperCamelCase_ = (accelerator.state.process_index + 2, 10) UpperCamelCase_ = torch.randint(0, 10, shape).to(accelerator.device) UpperCamelCase_ = """""" UpperCamelCase_ = accelerator.pad_across_processes(tensor) if tensora.shape[0] != accelerator.state.num_processes + 1: error_msg += F"Found shape {tensora.shape} but should have {accelerator.state.num_processes + 1} at dim 0." if not torch.equal(tensora[: accelerator.state.process_index + 2], tensor): error_msg += "Tensors have different values." if not torch.all(tensora[accelerator.state.process_index + 2 :] == 0): error_msg += "Padding was not done with the right value (0)." UpperCamelCase_ = accelerator.pad_across_processes(tensor, pad_first=True) if tensora.shape[0] != accelerator.state.num_processes + 1: error_msg += F"Found shape {tensora.shape} but should have {accelerator.state.num_processes + 1} at dim 0." UpperCamelCase_ = accelerator.state.num_processes - accelerator.state.process_index - 1 if not torch.equal(tensora[index:], tensor): error_msg += "Tensors have different values." if not torch.all(tensora[:index] == 0): error_msg += "Padding was not done with the right value (0)." # 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)

'''simple docstring''' from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, ) UpperCamelCase_ = {"""configuration_encoder_decoder""": ["""EncoderDecoderConfig"""]} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCamelCase_ = ["""EncoderDecoderModel"""] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCamelCase_ = ["""TFEncoderDecoderModel"""] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCamelCase_ = ["""FlaxEncoderDecoderModel"""] if TYPE_CHECKING: from .configuration_encoder_decoder import EncoderDecoderConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_encoder_decoder import EncoderDecoderModel try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_encoder_decoder import TFEncoderDecoderModel try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_encoder_decoder import FlaxEncoderDecoderModel else: import sys UpperCamelCase_ = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

"""simple docstring""" import logging import os from typing import Dict, List, Optional, Union import torch import torch.nn as nn from accelerate.utils.imports import ( is_abit_bnb_available, is_abit_bnb_available, is_bnb_available, ) from ..big_modeling import dispatch_model, init_empty_weights from .dataclasses import BnbQuantizationConfig from .modeling import ( find_tied_parameters, get_balanced_memory, infer_auto_device_map, load_checkpoint_in_model, offload_weight, set_module_tensor_to_device, ) if is_bnb_available(): import bitsandbytes as bnb from copy import deepcopy _lowercase : Tuple = logging.getLogger(__name__) def snake_case__ ( __lowerCamelCase : torch.nn.Module , __lowerCamelCase : BnbQuantizationConfig , __lowerCamelCase : Union[str, os.PathLike] = None , __lowerCamelCase : Optional[Dict[str, Union[int, str, torch.device]]] = None , __lowerCamelCase : Optional[List[str]] = None , __lowerCamelCase : Optional[Dict[Union[int, str], Union[int, str]]] = None , __lowerCamelCase : Optional[Union[str, os.PathLike]] = None , __lowerCamelCase : bool = False , ): """simple docstring""" lowerCamelCase__ : str =bnb_quantization_config.load_in_abit lowerCamelCase__ : str =bnb_quantization_config.load_in_abit if load_in_abit and not is_abit_bnb_available(): raise ImportError( '''You have a version of `bitsandbytes` that is not compatible with 8bit quantization,''' ''' make sure you have the latest version of `bitsandbytes` installed.''' ) if load_in_abit and not is_abit_bnb_available(): raise ValueError( '''You have a version of `bitsandbytes` that is not compatible with 4bit quantization,''' '''make sure you have the latest version of `bitsandbytes` installed.''' ) lowerCamelCase__ : str =[] # custom device map if isinstance(__lowerCamelCase , __lowerCamelCase ) and len(device_map.keys() ) > 1: lowerCamelCase__ : Union[str, Any] =[key for key, value in device_map.items() if value in ['''disk''', '''cpu''']] # We keep some modules such as the lm_head in their original dtype for numerical stability reasons if bnb_quantization_config.skip_modules is None: lowerCamelCase__ : Any =get_keys_to_not_convert(__lowerCamelCase ) # add cpu modules to skip modules only for 4-bit modules if load_in_abit: bnb_quantization_config.skip_modules.extend(__lowerCamelCase ) lowerCamelCase__ : Tuple =bnb_quantization_config.skip_modules # We add the modules we want to keep in full precision if bnb_quantization_config.keep_in_fpaa_modules is None: lowerCamelCase__ : Optional[Any] =[] lowerCamelCase__ : List[Any] =bnb_quantization_config.keep_in_fpaa_modules modules_to_not_convert.extend(__lowerCamelCase ) # compatibility with peft lowerCamelCase__ : List[str] =load_in_abit lowerCamelCase__ : List[str] =load_in_abit lowerCamelCase__ : Union[str, Any] =get_parameter_device(__lowerCamelCase ) if model_device.type != "meta": # quantization of an already loaded model logger.warning( '''It is not recommended to quantize a loaded model. ''' '''The model should be instantiated under the `init_empty_weights` context manager.''' ) lowerCamelCase__ : str =replace_with_bnb_layers(__lowerCamelCase , __lowerCamelCase , modules_to_not_convert=__lowerCamelCase ) # convert param to the right dtype lowerCamelCase__ : Union[str, Any] =bnb_quantization_config.torch_dtype for name, param in model.state_dict().items(): if any(module_to_keep_in_fpaa in name for module_to_keep_in_fpaa in keep_in_fpaa_modules ): param.to(torch.floataa ) if param.dtype != torch.floataa: lowerCamelCase__ : Optional[int] =name.replace('''.weight''' , '''''' ).replace('''.bias''' , '''''' ) lowerCamelCase__ : Dict =getattr(__lowerCamelCase , __lowerCamelCase , __lowerCamelCase ) if param is not None: param.to(torch.floataa ) elif torch.is_floating_point(__lowerCamelCase ): param.to(__lowerCamelCase ) if model_device.type == "cuda": # move everything to cpu in the first place because we can't do quantization if the weights are already on cuda model.cuda(torch.cuda.current_device() ) torch.cuda.empty_cache() elif torch.cuda.is_available(): model.to(torch.cuda.current_device() ) else: raise RuntimeError('''No GPU found. A GPU is needed for quantization.''' ) logger.info( f'''The model device type is {model_device.type}. However, cuda is needed for quantization.''' '''We move the model to cuda.''' ) return model elif weights_location is None: raise RuntimeError( f'''`weights_location` needs to be the folder path containing the weights of the model, but we found {weights_location} ''' ) else: with init_empty_weights(): lowerCamelCase__ : Dict =replace_with_bnb_layers( __lowerCamelCase , __lowerCamelCase , modules_to_not_convert=__lowerCamelCase ) lowerCamelCase__ : Optional[int] =get_quantized_model_device_map( __lowerCamelCase , __lowerCamelCase , __lowerCamelCase , max_memory=__lowerCamelCase , no_split_module_classes=__lowerCamelCase , ) if offload_state_dict is None and device_map is not None and "disk" in device_map.values(): lowerCamelCase__ : List[str] =True lowerCamelCase__ : Dict =any(x in list(device_map.values() ) for x in ['''cpu''', '''disk'''] ) load_checkpoint_in_model( __lowerCamelCase , __lowerCamelCase , __lowerCamelCase , dtype=bnb_quantization_config.torch_dtype , offload_folder=__lowerCamelCase , offload_state_dict=__lowerCamelCase , keep_in_fpaa_modules=bnb_quantization_config.keep_in_fpaa_modules , offload_abit_bnb=load_in_abit and offload , ) return dispatch_model(__lowerCamelCase , device_map=__lowerCamelCase , offload_dir=__lowerCamelCase ) def snake_case__ ( __lowerCamelCase : Dict , __lowerCamelCase : Any , __lowerCamelCase : Optional[Any]=None , __lowerCamelCase : Tuple=None , __lowerCamelCase : Optional[int]=None ): """simple docstring""" if device_map is None: if torch.cuda.is_available(): lowerCamelCase__ : List[Any] ={'''''': torch.cuda.current_device()} else: raise RuntimeError('''No GPU found. A GPU is needed for quantization.''' ) logger.info('''The device_map was not initialized.''' '''Setting device_map to `{\'\':torch.cuda.current_device()}`.''' ) if isinstance(__lowerCamelCase , __lowerCamelCase ): if device_map not in ["auto", "balanced", "balanced_low_0", "sequential"]: raise ValueError( '''If passing a string for `device_map`, please choose \'auto\', \'balanced\', \'balanced_low_0\' or ''' '''\'sequential\'.''' ) lowerCamelCase__ : List[Any] ={} special_dtypes.update( { name: bnb_quantization_config.torch_dtype for name, _ in model.named_parameters() if any(m in name for m in bnb_quantization_config.skip_modules ) } ) special_dtypes.update( { name: torch.floataa for name, _ in model.named_parameters() if any(m in name for m in bnb_quantization_config.keep_in_fpaa_modules ) } ) lowerCamelCase__ : int ={} lowerCamelCase__ : Optional[int] =special_dtypes lowerCamelCase__ : List[str] =no_split_module_classes lowerCamelCase__ : Tuple =bnb_quantization_config.target_dtype # get max_memory for each device. if device_map != "sequential": lowerCamelCase__ : List[str] =get_balanced_memory( __lowerCamelCase , low_zero=(device_map == '''balanced_low_0''') , max_memory=__lowerCamelCase , **__lowerCamelCase , ) lowerCamelCase__ : str =max_memory lowerCamelCase__ : Any =infer_auto_device_map(__lowerCamelCase , **__lowerCamelCase ) if isinstance(__lowerCamelCase , __lowerCamelCase ): # check if don't have any quantized module on the cpu lowerCamelCase__ : List[str] =bnb_quantization_config.skip_modules + bnb_quantization_config.keep_in_fpaa_modules lowerCamelCase__ : List[str] ={ key: device_map[key] for key in device_map.keys() if key not in modules_not_to_convert } for device in ["cpu", "disk"]: if device in device_map_without_some_modules.values(): if bnb_quantization_config.load_in_abit: raise ValueError( ''' Some modules are dispatched on the CPU or the disk. Make sure you have enough GPU RAM to fit the quantized model. If you want to dispatch the model on the CPU or the disk while keeping these modules in `torch_dtype`, you need to pass a custom `device_map` to `load_and_quantize_model`. Check https://huggingface.co/docs/accelerate/main/en/usage_guides/quantization#offload-modules-to-cpu-and-disk for more details. ''' ) else: logger.info( '''Some modules are are offloaded to the CPU or the disk. Note that these modules will be converted to 8-bit''' ) del device_map_without_some_modules return device_map def snake_case__ ( __lowerCamelCase : List[Any] , __lowerCamelCase : Union[str, Any] , __lowerCamelCase : Union[str, Any]=None , __lowerCamelCase : str=None ): """simple docstring""" if modules_to_not_convert is None: lowerCamelCase__ : Dict =[] lowerCamelCase__ , lowerCamelCase__ : List[Any] =_replace_with_bnb_layers( __lowerCamelCase , __lowerCamelCase , __lowerCamelCase , __lowerCamelCase ) if not has_been_replaced: logger.warning( '''You are loading your model in 8bit or 4bit but no linear modules were found in your model.''' ''' this can happen for some architectures such as gpt2 that uses Conv1D instead of Linear layers.''' ''' Please double check your model architecture, or submit an issue on github if you think this is''' ''' a bug.''' ) return model def snake_case__ ( __lowerCamelCase : List[Any] , __lowerCamelCase : int , __lowerCamelCase : int=None , __lowerCamelCase : Optional[Any]=None , ): """simple docstring""" lowerCamelCase__ : Tuple =False for name, module in model.named_children(): if current_key_name is None: lowerCamelCase__ : Optional[Any] =[] current_key_name.append(__lowerCamelCase ) if isinstance(__lowerCamelCase , nn.Linear ) and name not in modules_to_not_convert: # Check if the current key is not in the `modules_to_not_convert` lowerCamelCase__ : Optional[Any] ='''.'''.join(__lowerCamelCase ) lowerCamelCase__ : Tuple =True for key in modules_to_not_convert: if ( (key in current_key_name_str) and (key + "." in current_key_name_str) ) or key == current_key_name_str: lowerCamelCase__ : Any =False break if proceed: # Load bnb module with empty weight and replace ``nn.Linear` module if bnb_quantization_config.load_in_abit: lowerCamelCase__ : List[str] =bnb.nn.LinearabitLt( module.in_features , module.out_features , module.bias is not None , has_fpaa_weights=__lowerCamelCase , threshold=bnb_quantization_config.llm_inta_threshold , ) elif bnb_quantization_config.load_in_abit: lowerCamelCase__ : str =bnb.nn.Linearabit( module.in_features , module.out_features , module.bias is not None , bnb_quantization_config.bnb_abit_compute_dtype , compress_statistics=bnb_quantization_config.bnb_abit_use_double_quant , quant_type=bnb_quantization_config.bnb_abit_quant_type , ) else: raise ValueError('''load_in_8bit and load_in_4bit can\'t be both False''' ) lowerCamelCase__ : Any =module.weight.data if module.bias is not None: lowerCamelCase__ : Any =module.bias.data bnb_module.requires_grad_(__lowerCamelCase ) setattr(__lowerCamelCase , __lowerCamelCase , __lowerCamelCase ) lowerCamelCase__ : str =True if len(list(module.children() ) ) > 0: lowerCamelCase__ , lowerCamelCase__ : Optional[int] =_replace_with_bnb_layers( __lowerCamelCase , __lowerCamelCase , __lowerCamelCase , __lowerCamelCase ) lowerCamelCase__ : Any =has_been_replaced | _has_been_replaced # Remove the last key for recursion current_key_name.pop(-1 ) return model, has_been_replaced def snake_case__ ( __lowerCamelCase : Union[str, Any] ): """simple docstring""" # Create a copy of the model with init_empty_weights(): lowerCamelCase__ : Optional[Any] =deepcopy(__lowerCamelCase ) # this has 0 cost since it is done inside `init_empty_weights` context manager` lowerCamelCase__ : Union[str, Any] =find_tied_parameters(__lowerCamelCase ) # For compatibility with Accelerate < 0.18 if isinstance(__lowerCamelCase , __lowerCamelCase ): lowerCamelCase__ : List[str] =sum(list(tied_params.values() ) , [] ) + list(tied_params.keys() ) else: lowerCamelCase__ : Any =sum(__lowerCamelCase , [] ) lowerCamelCase__ : Any =len(__lowerCamelCase ) > 0 # Check if it is a base model lowerCamelCase__ : Optional[Any] =False if hasattr(__lowerCamelCase , '''base_model_prefix''' ): lowerCamelCase__ : Dict =not hasattr(__lowerCamelCase , model.base_model_prefix ) # Ignore this for base models (BertModel, GPT2Model, etc.) if (not has_tied_params) and is_base_model: return [] # otherwise they have an attached head lowerCamelCase__ : List[str] =list(model.named_children() ) lowerCamelCase__ : Any =[list_modules[-1][0]] # add last module together with tied weights lowerCamelCase__ : Optional[Any] =set(__lowerCamelCase ) - set(__lowerCamelCase ) lowerCamelCase__ : List[str] =list(set(__lowerCamelCase ) ) + list(__lowerCamelCase ) # remove ".weight" from the keys lowerCamelCase__ : Optional[Any] =['''.weight''', '''.bias'''] lowerCamelCase__ : List[Any] =[] for name in list_untouched: for name_to_remove in names_to_remove: if name_to_remove in name: lowerCamelCase__ : Union[str, Any] =name.replace(__lowerCamelCase , '''''' ) filtered_module_names.append(__lowerCamelCase ) return filtered_module_names def snake_case__ ( __lowerCamelCase : Tuple ): """simple docstring""" for m in model.modules(): if isinstance(__lowerCamelCase , bnb.nn.Linearabit ): return True return False def snake_case__ ( __lowerCamelCase : nn.Module ): """simple docstring""" return next(parameter.parameters() ).device def snake_case__ ( __lowerCamelCase : List[str] , __lowerCamelCase : Tuple , __lowerCamelCase : Any , __lowerCamelCase : Any , __lowerCamelCase : Optional[int] , __lowerCamelCase : int , __lowerCamelCase : Optional[int] ): """simple docstring""" # if it is not quantized, we quantize and offload the quantized weights and the SCB stats if fpaa_statistics is None: set_module_tensor_to_device(__lowerCamelCase , __lowerCamelCase , 0 , dtype=__lowerCamelCase , value=__lowerCamelCase ) lowerCamelCase__ : Union[str, Any] =param_name lowerCamelCase__ : Dict =model if "." in tensor_name: lowerCamelCase__ : Optional[int] =tensor_name.split('''.''' ) for split in splits[:-1]: lowerCamelCase__ : Union[str, Any] =getattr(__lowerCamelCase , __lowerCamelCase ) if new_module is None: raise ValueError(f'''{module} has no attribute {split}.''' ) lowerCamelCase__ : Union[str, Any] =new_module lowerCamelCase__ : List[Any] =splits[-1] # offload weights lowerCamelCase__ : Optional[Any] =False offload_weight(module._parameters[tensor_name] , __lowerCamelCase , __lowerCamelCase , index=__lowerCamelCase ) if hasattr(module._parameters[tensor_name] , '''SCB''' ): offload_weight( module._parameters[tensor_name].SCB , param_name.replace('''weight''' , '''SCB''' ) , __lowerCamelCase , index=__lowerCamelCase , ) else: offload_weight(__lowerCamelCase , __lowerCamelCase , __lowerCamelCase , index=__lowerCamelCase ) offload_weight(__lowerCamelCase , param_name.replace('''weight''' , '''SCB''' ) , __lowerCamelCase , index=__lowerCamelCase ) set_module_tensor_to_device(__lowerCamelCase , __lowerCamelCase , '''meta''' , dtype=__lowerCamelCase , value=torch.empty(*param.size() ) )

"""simple docstring""" import argparse import torch from transformers import YosoConfig, YosoForMaskedLM def snake_case__ ( __lowerCamelCase : str ): """simple docstring""" if "model" in orig_key: lowerCamelCase__ : Optional[int] =orig_key.replace('''model.''' , '''''' ) if "norm1" in orig_key: lowerCamelCase__ : Union[str, Any] =orig_key.replace('''norm1''' , '''attention.output.LayerNorm''' ) if "norm2" in orig_key: lowerCamelCase__ : List[Any] =orig_key.replace('''norm2''' , '''output.LayerNorm''' ) if "norm" in orig_key: lowerCamelCase__ : List[str] =orig_key.replace('''norm''' , '''LayerNorm''' ) if "transformer" in orig_key: lowerCamelCase__ : str =orig_key.split('''.''' )[0].split('''_''' )[-1] lowerCamelCase__ : Dict =orig_key.replace(f'''transformer_{layer_num}''' , f'''encoder.layer.{layer_num}''' ) if "mha.attn" in orig_key: lowerCamelCase__ : Union[str, Any] =orig_key.replace('''mha.attn''' , '''attention.self''' ) if "mha" in orig_key: lowerCamelCase__ : str =orig_key.replace('''mha''' , '''attention''' ) if "W_q" in orig_key: lowerCamelCase__ : Union[str, Any] =orig_key.replace('''W_q''' , '''self.query''' ) if "W_k" in orig_key: lowerCamelCase__ : Optional[int] =orig_key.replace('''W_k''' , '''self.key''' ) if "W_v" in orig_key: lowerCamelCase__ : List[str] =orig_key.replace('''W_v''' , '''self.value''' ) if "ff1" in orig_key: lowerCamelCase__ : Dict =orig_key.replace('''ff1''' , '''intermediate.dense''' ) if "ff2" in orig_key: lowerCamelCase__ : Union[str, Any] =orig_key.replace('''ff2''' , '''output.dense''' ) if "ff" in orig_key: lowerCamelCase__ : str =orig_key.replace('''ff''' , '''output.dense''' ) if "mlm_class" in orig_key: lowerCamelCase__ : Tuple =orig_key.replace('''mlm.mlm_class''' , '''cls.predictions.decoder''' ) if "mlm" in orig_key: lowerCamelCase__ : Optional[int] =orig_key.replace('''mlm''' , '''cls.predictions.transform''' ) if "cls" not in orig_key: lowerCamelCase__ : Optional[int] ='''yoso.''' + orig_key return orig_key def snake_case__ ( __lowerCamelCase : List[str] , __lowerCamelCase : Any ): """simple docstring""" for key in orig_state_dict.copy().keys(): lowerCamelCase__ : Optional[Any] =orig_state_dict.pop(__lowerCamelCase ) if ("pooler" in key) or ("sen_class" in key): continue else: lowerCamelCase__ : List[str] =val lowerCamelCase__ : Optional[int] =orig_state_dict['''cls.predictions.decoder.bias'''] lowerCamelCase__ : str =torch.arange(__lowerCamelCase ).expand((1, -1) ) + 2 return orig_state_dict def snake_case__ ( __lowerCamelCase : str , __lowerCamelCase : Tuple , __lowerCamelCase : Tuple ): """simple docstring""" lowerCamelCase__ : Union[str, Any] =torch.load(__lowerCamelCase , map_location='''cpu''' )['''model_state_dict'''] lowerCamelCase__ : List[Any] =YosoConfig.from_json_file(__lowerCamelCase ) lowerCamelCase__ : List[str] =YosoForMaskedLM(__lowerCamelCase ) lowerCamelCase__ : Tuple =convert_checkpoint_helper(config.max_position_embeddings , __lowerCamelCase ) print(model.load_state_dict(__lowerCamelCase ) ) model.eval() model.save_pretrained(__lowerCamelCase ) print(f'''Checkpoint successfuly converted. Model saved at {pytorch_dump_path}''' ) if __name__ == "__main__": _lowercase : int = argparse.ArgumentParser() # Required parameters parser.add_argument( "--pytorch_model_path", default=None, type=str, required=True, help="Path to YOSO pytorch checkpoint." ) parser.add_argument( "--config_file", default=None, type=str, required=True, help="The json file for YOSO model config.", ) parser.add_argument( "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model." ) _lowercase : Optional[Any] = parser.parse_args() convert_yoso_checkpoint(args.pytorch_model_path, args.config_file, args.pytorch_dump_path)

"""simple docstring""" import json import os import tempfile import unittest import numpy as np from datasets import load_dataset from transformers.testing_utils import require_torch, require_vision, slow from transformers.utils import is_torch_available, is_vision_available from ...test_image_processing_common import ImageProcessingSavingTestMixin if is_torch_available(): import torch if is_vision_available(): from PIL import Image from transformers import ImageGPTImageProcessor class lowerCamelCase__ ( unittest.TestCase ): def __init__( self , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE=7 , SCREAMING_SNAKE_CASE=3 , SCREAMING_SNAKE_CASE=18 , SCREAMING_SNAKE_CASE=30 , SCREAMING_SNAKE_CASE=400 , SCREAMING_SNAKE_CASE=True , SCREAMING_SNAKE_CASE=None , SCREAMING_SNAKE_CASE=True , ): """simple docstring""" snake_case : List[str] = size if size is not None else {"height": 18, "width": 18} snake_case : List[str] = parent snake_case : int = batch_size snake_case : Tuple = num_channels snake_case : List[Any] = image_size snake_case : Union[str, Any] = min_resolution snake_case : List[str] = max_resolution snake_case : List[str] = do_resize snake_case : List[Any] = size snake_case : Any = do_normalize def lowerCamelCase_ ( self ): """simple docstring""" return { # here we create 2 clusters for the sake of simplicity "clusters": np.asarray( [ [0.88_66_44_36_34_03_32_03, 0.66_18_82_93_69_54_49_83, 0.38_91_74_64_01_78_68_04], [-0.60_42_55_91_46_88_11_04, -0.0_22_95_00_88_60_52_84_69, 0.54_23_79_73_69_00_32_96], ] ), "do_resize": self.do_resize, "size": self.size, "do_normalize": self.do_normalize, } @require_torch @require_vision class lowerCamelCase__ ( lowerCamelCase_ , unittest.TestCase ): a__ : str = ImageGPTImageProcessor if is_vision_available() else None def lowerCamelCase_ ( self ): """simple docstring""" snake_case : Union[str, Any] = ImageGPTImageProcessingTester(self ) @property def lowerCamelCase_ ( self ): """simple docstring""" return self.image_processor_tester.prepare_image_processor_dict() def lowerCamelCase_ ( self ): """simple docstring""" snake_case : Union[str, Any] = self.image_processing_class(**self.image_processor_dict ) self.assertTrue(hasattr(SCREAMING_SNAKE_CASE , "clusters" ) ) self.assertTrue(hasattr(SCREAMING_SNAKE_CASE , "do_resize" ) ) self.assertTrue(hasattr(SCREAMING_SNAKE_CASE , "size" ) ) self.assertTrue(hasattr(SCREAMING_SNAKE_CASE , "do_normalize" ) ) def lowerCamelCase_ ( self ): """simple docstring""" snake_case : int = self.image_processing_class.from_dict(self.image_processor_dict ) self.assertEqual(image_processor.size , {"height": 18, "width": 18} ) snake_case : Optional[Any] = self.image_processing_class.from_dict(self.image_processor_dict , size=42 ) self.assertEqual(image_processor.size , {"height": 42, "width": 42} ) def lowerCamelCase_ ( self ): """simple docstring""" snake_case : Union[str, Any] = self.image_processing_class(**self.image_processor_dict ) snake_case : List[str] = json.loads(image_processor.to_json_string() ) for key, value in self.image_processor_dict.items(): if key == "clusters": self.assertTrue(np.array_equal(SCREAMING_SNAKE_CASE , obj[key] ) ) else: self.assertEqual(obj[key] , SCREAMING_SNAKE_CASE ) def lowerCamelCase_ ( self ): """simple docstring""" snake_case : List[str] = self.image_processing_class(**self.image_processor_dict ) with tempfile.TemporaryDirectory() as tmpdirname: snake_case : List[str] = os.path.join(SCREAMING_SNAKE_CASE , "image_processor.json" ) image_processor_first.to_json_file(SCREAMING_SNAKE_CASE ) snake_case : Any = self.image_processing_class.from_json_file(SCREAMING_SNAKE_CASE ).to_dict() snake_case : int = image_processor_first.to_dict() for key, value in image_processor_first.items(): if key == "clusters": self.assertTrue(np.array_equal(SCREAMING_SNAKE_CASE , image_processor_second[key] ) ) else: self.assertEqual(image_processor_first[key] , SCREAMING_SNAKE_CASE ) def lowerCamelCase_ ( self ): """simple docstring""" snake_case : Dict = self.image_processing_class(**self.image_processor_dict ) with tempfile.TemporaryDirectory() as tmpdirname: image_processor_first.save_pretrained(SCREAMING_SNAKE_CASE ) snake_case : Tuple = self.image_processing_class.from_pretrained(SCREAMING_SNAKE_CASE ).to_dict() snake_case : Any = image_processor_first.to_dict() for key, value in image_processor_first.items(): if key == "clusters": self.assertTrue(np.array_equal(SCREAMING_SNAKE_CASE , image_processor_second[key] ) ) else: self.assertEqual(image_processor_first[key] , SCREAMING_SNAKE_CASE ) @unittest.skip("ImageGPT requires clusters at initialization" ) def lowerCamelCase_ ( self ): """simple docstring""" pass def UpperCamelCase__ ( ): snake_case : Optional[int] = load_dataset("hf-internal-testing/fixtures_image_utils" , split="test" ) snake_case : Union[str, Any] = Image.open(dataset[4]["file"] ) snake_case : Dict = Image.open(dataset[5]["file"] ) snake_case : List[Any] = [imagea, imagea] return images @require_vision @require_torch class lowerCamelCase__ ( unittest.TestCase ): @slow def lowerCamelCase_ ( self ): """simple docstring""" snake_case : Optional[Any] = ImageGPTImageProcessor.from_pretrained("openai/imagegpt-small" ) snake_case : Optional[Any] = prepare_images() # test non-batched snake_case : Optional[int] = image_processing(images[0] , return_tensors="pt" ) self.assertIsInstance(encoding.input_ids , torch.LongTensor ) self.assertEqual(encoding.input_ids.shape , (1, 1_024) ) snake_case : List[Any] = [306, 191, 191] self.assertEqual(encoding.input_ids[0, :3].tolist() , SCREAMING_SNAKE_CASE ) # test batched snake_case : Union[str, Any] = image_processing(SCREAMING_SNAKE_CASE , return_tensors="pt" ) self.assertIsInstance(encoding.input_ids , torch.LongTensor ) self.assertEqual(encoding.input_ids.shape , (2, 1_024) ) snake_case : Union[str, Any] = [303, 13, 13] self.assertEqual(encoding.input_ids[1, -3:].tolist() , SCREAMING_SNAKE_CASE )

"""simple docstring""" from typing import Any class lowerCamelCase__ : def __init__( self , SCREAMING_SNAKE_CASE ): """simple docstring""" snake_case : Tuple = data snake_case : Union[str, Any] = None class lowerCamelCase__ : def __init__( self ): """simple docstring""" snake_case : List[Any] = None def lowerCamelCase_ ( self ): """simple docstring""" snake_case : str = self.head while temp is not None: print(temp.data , end=" " ) snake_case : Optional[Any] = temp.next print() def lowerCamelCase_ ( self , SCREAMING_SNAKE_CASE ): """simple docstring""" snake_case : Union[str, Any] = Node(SCREAMING_SNAKE_CASE ) snake_case : List[Any] = self.head snake_case : Optional[int] = new_node def lowerCamelCase_ ( self , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE ): """simple docstring""" if node_data_a == node_data_a: return else: snake_case : int = self.head while node_a is not None and node_a.data != node_data_a: snake_case : Optional[Any] = node_a.next snake_case : Tuple = self.head while node_a is not None and node_a.data != node_data_a: snake_case : Union[str, Any] = node_a.next if node_a is None or node_a is None: return snake_case , snake_case : int = node_a.data, node_a.data if __name__ == "__main__": __A = LinkedList() for i in range(5, 0, -1): ll.push(i) ll.print_list() ll.swap_nodes(1, 4) print("After swapping") ll.print_list()

import argparse import torch # Step 1. clone https://github.com/microsoft/unilm # Step 2. git checkout to https://github.com/microsoft/unilm/commit/b94ec76c36f02fb2b0bf0dcb0b8554a2185173cd # Step 3. cd unilm # Step 4. ln -s $(realpath wavlm/modules.py) ./ # create simlink # import classes from unilm.wavlm.WavLM import WavLM as WavLMOrig from unilm.wavlm.WavLM import WavLMConfig as WavLMConfigOrig from transformers import WavLMConfig, WavLMModel, logging logging.set_verbosity_info() __A = logging.get_logger(__name__) __A = { '''post_extract_proj''': '''feature_projection.projection''', '''encoder.pos_conv.0''': '''encoder.pos_conv_embed.conv''', '''self_attn.k_proj''': '''encoder.layers.*.attention.k_proj''', '''self_attn.v_proj''': '''encoder.layers.*.attention.v_proj''', '''self_attn.q_proj''': '''encoder.layers.*.attention.q_proj''', '''self_attn.out_proj''': '''encoder.layers.*.attention.out_proj''', '''self_attn.grep_linear''': '''encoder.layers.*.attention.gru_rel_pos_linear''', '''self_attn.relative_attention_bias''': '''encoder.layers.*.attention.rel_attn_embed''', '''self_attn.grep_a''': '''encoder.layers.*.attention.gru_rel_pos_const''', '''self_attn_layer_norm''': '''encoder.layers.*.layer_norm''', '''fc1''': '''encoder.layers.*.feed_forward.intermediate_dense''', '''fc2''': '''encoder.layers.*.feed_forward.output_dense''', '''final_layer_norm''': '''encoder.layers.*.final_layer_norm''', '''encoder.layer_norm''': '''encoder.layer_norm''', '''w2v_model.layer_norm''': '''feature_projection.layer_norm''', '''quantizer.weight_proj''': '''quantizer.weight_proj''', '''quantizer.vars''': '''quantizer.codevectors''', '''project_q''': '''project_q''', '''final_proj''': '''project_hid''', '''w2v_encoder.proj''': '''ctc_proj''', '''mask_emb''': '''masked_spec_embed''', } __A = [ '''ctc_proj''', '''quantizer.weight_proj''', '''quantizer.codevectors''', '''project_q''', '''project_hid''', ] def snake_case_(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Dict: """simple docstring""" for attribute in key.split('''.''' ): _snake_case = getattr(_UpperCamelCase , _UpperCamelCase ) if weight_type is not None: _snake_case = getattr(_UpperCamelCase , _UpperCamelCase ).shape else: _snake_case = hf_pointer.shape assert hf_shape == value.shape, ( F"""Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be""" F""" {value.shape} for {full_name}""" ) if weight_type == "weight": _snake_case = value elif weight_type == "weight_g": _snake_case = value elif weight_type == "weight_v": _snake_case = value elif weight_type == "bias": _snake_case = value else: _snake_case = value logger.info(F"""{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}.""" ) def snake_case_(_UpperCamelCase , _UpperCamelCase ) -> Dict: """simple docstring""" _snake_case = [] _snake_case = fairseq_model.state_dict() _snake_case = hf_model.feature_extractor for name, value in fairseq_dict.items(): _snake_case = False if "conv_layers" in name: load_conv_layer( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , hf_model.config.feat_extract_norm == '''group''' , ) _snake_case = True else: for key, mapped_key in MAPPING.items(): if key in name or key.split('''w2v_model.''' )[-1] == name.split('''.''' )[0]: _snake_case = True if "*" in mapped_key: _snake_case = name.split(_UpperCamelCase )[0].split('''.''' )[-2] _snake_case = mapped_key.replace('''*''' , _UpperCamelCase ) if "weight_g" in name: _snake_case = '''weight_g''' elif "weight_v" in name: _snake_case = '''weight_v''' elif "bias" in name and "relative_attention_bias" not in name: _snake_case = '''bias''' elif "weight" in name: # TODO: don't match quantizer.weight_proj _snake_case = '''weight''' else: _snake_case = None set_recursively(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) continue if not is_used: unused_weights.append(_UpperCamelCase ) logger.warning(F"""Unused weights: {unused_weights}""" ) def snake_case_(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Union[str, Any]: """simple docstring""" _snake_case = full_name.split('''conv_layers.''' )[-1] _snake_case = name.split('''.''' ) _snake_case = int(items[0] ) _snake_case = int(items[1] ) if type_id == 0: if "bias" in name: assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, ( F"""{full_name} has size {value.shape}, but""" F""" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found.""" ) _snake_case = value logger.info(F"""Feat extract conv layer {layer_id} was initialized from {full_name}.""" ) elif "weight" in name: assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, ( F"""{full_name} has size {value.shape}, but""" F""" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.""" ) _snake_case = value logger.info(F"""Feat extract conv layer {layer_id} was initialized from {full_name}.""" ) elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm): if "bias" in name: assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, ( F"""{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was""" " found." ) _snake_case = value logger.info(F"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.""" ) elif "weight" in name: assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, ( F"""{full_name} has size {value.shape}, but""" F""" {feature_extractor[layer_id].layer_norm.weight.data.shape} was found.""" ) _snake_case = value logger.info(F"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.""" ) else: unused_weights.append(_UpperCamelCase ) @torch.no_grad() def snake_case_(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase=None ) -> Tuple: """simple docstring""" _snake_case = torch.load(_UpperCamelCase ) _snake_case = WavLMConfigOrig(checkpoint['''cfg'''] ) _snake_case = WavLMOrig(_UpperCamelCase ) model.load_state_dict(checkpoint['''model'''] ) model.eval() if config_path is not None: _snake_case = WavLMConfig.from_pretrained(_UpperCamelCase ) else: _snake_case = WavLMConfig() _snake_case = WavLMModel(_UpperCamelCase ) recursively_load_weights(_UpperCamelCase , _UpperCamelCase ) hf_wavlm.save_pretrained(_UpperCamelCase ) if __name__ == "__main__": __A = argparse.ArgumentParser() parser.add_argument('''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model.''') parser.add_argument('''--checkpoint_path''', default=None, type=str, help='''Path to fairseq checkpoint''') parser.add_argument('''--config_path''', default=None, type=str, help='''Path to hf config.json of model to convert''') __A = parser.parse_args() convert_wavlm_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)

import argparse import torch from ...utils import logging from . import AlbertConfig, AlbertForPreTraining, load_tf_weights_in_albert logging.set_verbosity_info() def snake_case_(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Optional[Any]: """simple docstring""" _snake_case = AlbertConfig.from_json_file(_UpperCamelCase ) print(F"""Building PyTorch model from configuration: {config}""" ) _snake_case = AlbertForPreTraining(_UpperCamelCase ) # Load weights from tf checkpoint load_tf_weights_in_albert(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # Save pytorch-model print(F"""Save PyTorch model to {pytorch_dump_path}""" ) torch.save(model.state_dict() , _UpperCamelCase ) if __name__ == "__main__": __A = argparse.ArgumentParser() # Required parameters parser.add_argument( '''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.''' ) parser.add_argument( '''--albert_config_file''', default=None, type=str, required=True, help=( '''The config json file corresponding to the pre-trained ALBERT model. \n''' '''This specifies the model architecture.''' ), ) parser.add_argument( '''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.''' ) __A = parser.parse_args() convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.albert_config_file, args.pytorch_dump_path)

from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging UpperCamelCase__ = logging.get_logger(__name__) UpperCamelCase__ = { 'andreasmadsen/efficient_mlm_m0.40': ( 'https://huggingface.co/andreasmadsen/efficient_mlm_m0.40/resolve/main/config.json' ), } class A ( UpperCAmelCase_ ): __UpperCAmelCase : int = 'roberta-prelayernorm' def __init__(self : Optional[Any] , __UpperCAmelCase : Optional[int]=5_0_2_6_5 , __UpperCAmelCase : List[str]=7_6_8 , __UpperCAmelCase : List[Any]=1_2 , __UpperCAmelCase : Any=1_2 , __UpperCAmelCase : Optional[int]=3_0_7_2 , __UpperCAmelCase : int="gelu" , __UpperCAmelCase : int=0.1 , __UpperCAmelCase : Optional[Any]=0.1 , __UpperCAmelCase : Union[str, Any]=5_1_2 , __UpperCAmelCase : List[Any]=2 , __UpperCAmelCase : Tuple=0.02 , __UpperCAmelCase : List[str]=1E-12 , __UpperCAmelCase : Any=1 , __UpperCAmelCase : Optional[int]=0 , __UpperCAmelCase : List[str]=2 , __UpperCAmelCase : Dict="absolute" , __UpperCAmelCase : List[Any]=True , __UpperCAmelCase : str=None , **__UpperCAmelCase : Dict , ) -> Optional[Any]: """simple docstring""" super().__init__(pad_token_id=__UpperCAmelCase , bos_token_id=__UpperCAmelCase , eos_token_id=__UpperCAmelCase , **__UpperCAmelCase ) UpperCAmelCase__ = vocab_size UpperCAmelCase__ = hidden_size UpperCAmelCase__ = num_hidden_layers UpperCAmelCase__ = num_attention_heads UpperCAmelCase__ = hidden_act UpperCAmelCase__ = intermediate_size UpperCAmelCase__ = hidden_dropout_prob UpperCAmelCase__ = attention_probs_dropout_prob UpperCAmelCase__ = max_position_embeddings UpperCAmelCase__ = type_vocab_size UpperCAmelCase__ = initializer_range UpperCAmelCase__ = layer_norm_eps UpperCAmelCase__ = position_embedding_type UpperCAmelCase__ = use_cache UpperCAmelCase__ = classifier_dropout class A ( UpperCAmelCase_ ): @property def lowercase_ (self : int ) -> Mapping[str, Mapping[int, str]]: """simple docstring""" if self.task == "multiple-choice": UpperCAmelCase__ = {0: "batch", 1: "choice", 2: "sequence"} else: UpperCAmelCase__ = {0: "batch", 1: "sequence"} return OrderedDict( [ ("input_ids", dynamic_axis), ("attention_mask", dynamic_axis), ] )

'''simple docstring''' import json import os import unittest from transformers.models.blenderbot_small.tokenization_blenderbot_small import ( VOCAB_FILES_NAMES, BlenderbotSmallTokenizer, ) from ...test_tokenization_common import TokenizerTesterMixin class UpperCAmelCase ( a__ , unittest.TestCase ): '''simple docstring''' SCREAMING_SNAKE_CASE = BlenderbotSmallTokenizer SCREAMING_SNAKE_CASE = False def _lowerCAmelCase( self ) -> Optional[int]: super().setUp() lowercase__ : List[Any] = ['''__start__''', '''adapt''', '''act''', '''ap@@''', '''te''', '''__end__''', '''__unk__'''] lowercase__ : Any = dict(zip(__lowerCAmelCase , range(len(__lowerCAmelCase ) ) ) ) lowercase__ : Optional[Any] = ['''#version: 0.2''', '''a p''', '''t e</w>''', '''ap t</w>''', '''a d''', '''ad apt</w>''', '''a c''', '''ac t</w>''', ''''''] lowercase__ : Dict = {'''unk_token''': '''__unk__''', '''bos_token''': '''__start__''', '''eos_token''': '''__end__'''} lowercase__ : List[str] = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['''vocab_file'''] ) lowercase__ : Any = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['''merges_file'''] ) with open(self.vocab_file , '''w''' , encoding='''utf-8''' ) as fp: fp.write(json.dumps(__lowerCAmelCase ) + '''\n''' ) with open(self.merges_file , '''w''' , encoding='''utf-8''' ) as fp: fp.write('''\n'''.join(__lowerCAmelCase ) ) def _lowerCAmelCase( self , **__lowerCAmelCase ) -> Tuple: kwargs.update(self.special_tokens_map ) return BlenderbotSmallTokenizer.from_pretrained(self.tmpdirname , **__lowerCAmelCase ) def _lowerCAmelCase( self , __lowerCAmelCase ) -> int: lowercase__ : str = '''adapt act apte''' lowercase__ : Any = '''adapt act apte''' return input_text, output_text def _lowerCAmelCase( self ) -> str: lowercase__ : Optional[int] = BlenderbotSmallTokenizer(self.vocab_file , self.merges_file , **self.special_tokens_map ) lowercase__ : Tuple = '''adapt act apte''' lowercase__ : Dict = ['''adapt''', '''act''', '''ap@@''', '''te'''] lowercase__ : Union[str, Any] = tokenizer.tokenize(__lowerCAmelCase ) self.assertListEqual(__lowerCAmelCase , __lowerCAmelCase ) lowercase__ : Any = [tokenizer.bos_token] + tokens + [tokenizer.eos_token] lowercase__ : int = [0, 1, 2, 3, 4, 5] self.assertListEqual(tokenizer.convert_tokens_to_ids(__lowerCAmelCase ) , __lowerCAmelCase ) def _lowerCAmelCase( self ) -> str: lowercase__ : int = BlenderbotSmallTokenizer.from_pretrained('''facebook/blenderbot-90M''' ) assert tok('''sam''' ).input_ids == [1384] lowercase__ : str = '''I am a small frog.''' lowercase__ : Union[str, Any] = tok([src_text] , padding=__lowerCAmelCase , truncation=__lowerCAmelCase )['''input_ids'''] lowercase__ : List[str] = tok.batch_decode(__lowerCAmelCase , skip_special_tokens=__lowerCAmelCase , clean_up_tokenization_spaces=__lowerCAmelCase )[0] assert src_text != decoded # I wish it did! assert decoded == "i am a small frog ." def _lowerCAmelCase( self ) -> Optional[Any]: lowercase__ : Optional[Any] = BlenderbotSmallTokenizer.from_pretrained('''facebook/blenderbot-90M''' ) lowercase__ : Optional[Any] = '''I am a small frog .''' lowercase__ : Any = '''.''' lowercase__ : List[Any] = tok(__lowerCAmelCase )['''input_ids'''] lowercase__ : Optional[Any] = tok(__lowerCAmelCase )['''input_ids'''] assert encoded[-1] == encoded_dot[0]

"""simple docstring""" import inspect import unittest from typing import List import numpy as np from transformers import EfficientFormerConfig from transformers.testing_utils import require_tf, require_vision, slow from transformers.utils import cached_property, is_tf_available, is_vision_available from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import tensorflow as tf from transformers import ( TFEfficientFormerForImageClassification, TFEfficientFormerForImageClassificationWithTeacher, TFEfficientFormerModel, ) from transformers.models.efficientformer.modeling_tf_efficientformer import ( TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, ) if is_vision_available(): from PIL import Image from transformers import EfficientFormerImageProcessor class _UpperCAmelCase : def __init__( self : List[Any] , lowercase_ : Any , lowercase_ : int = 13 , lowercase_ : int = 64 , lowercase_ : int = 2 , lowercase_ : int = 3 , lowercase_ : int = 3 , lowercase_ : bool = True , lowercase_ : bool = True , lowercase_ : int = 128 , lowercase_ : Any=[16, 32, 64, 128] , lowercase_ : int = 7 , lowercase_ : int = 4 , lowercase_ : int = 37 , lowercase_ : str = "gelu" , lowercase_ : float = 0.1 , lowercase_ : float = 0.1 , lowercase_ : int = 10 , lowercase_ : float = 0.02 , lowercase_ : int = 2 , lowercase_ : int = 1 , lowercase_ : int = 128 , lowercase_ : List[int] = [2, 2, 2, 2] , lowercase_ : int = 2 , lowercase_ : int = 2 , ): snake_case_ : List[str] = parent snake_case_ : List[Any] = batch_size snake_case_ : Dict = image_size snake_case_ : Tuple = patch_size snake_case_ : int = num_channels snake_case_ : Union[str, Any] = is_training snake_case_ : int = use_labels snake_case_ : Optional[int] = hidden_size snake_case_ : List[Any] = num_hidden_layers snake_case_ : Tuple = num_attention_heads snake_case_ : str = intermediate_size snake_case_ : int = hidden_act snake_case_ : Dict = hidden_dropout_prob snake_case_ : List[Any] = attention_probs_dropout_prob snake_case_ : Optional[int] = type_sequence_label_size snake_case_ : Union[str, Any] = initializer_range snake_case_ : Optional[int] = encoder_stride snake_case_ : int = num_attention_outputs snake_case_ : Any = embed_dim snake_case_ : Tuple = embed_dim + 1 snake_case_ : Union[str, Any] = resolution snake_case_ : List[Any] = depths snake_case_ : List[Any] = hidden_sizes snake_case_ : List[Any] = dim snake_case_ : Optional[int] = mlp_expansion_ratio def _snake_case ( self : int ): snake_case_ : Tuple = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) snake_case_ : str = None if self.use_labels: snake_case_ : List[str] = ids_tensor([self.batch_size] , self.type_sequence_label_size ) snake_case_ : int = self.get_config() return config, pixel_values, labels def _snake_case ( self : str ): return EfficientFormerConfig( image_size=self.image_size , patch_size=self.patch_size , num_channels=self.num_channels , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , is_decoder=lowercase_ , initializer_range=self.initializer_range , encoder_stride=self.encoder_stride , resolution=self.resolution , depths=self.depths , hidden_sizes=self.hidden_sizes , dim=self.dim , mlp_expansion_ratio=self.mlp_expansion_ratio , ) def _snake_case ( self : Optional[Any] , lowercase_ : Optional[int] , lowercase_ : List[Any] , lowercase_ : Dict ): snake_case_ : Any = TFEfficientFormerModel(config=lowercase_ ) snake_case_ : List[str] = model(lowercase_ , training=lowercase_ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def _snake_case ( self : Dict , lowercase_ : Any , lowercase_ : str , lowercase_ : List[str] ): snake_case_ : Union[str, Any] = self.type_sequence_label_size snake_case_ : List[str] = TFEfficientFormerForImageClassification(lowercase_ ) snake_case_ : Optional[int] = model(lowercase_ , labels=lowercase_ , training=lowercase_ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.type_sequence_label_size) ) # test greyscale images snake_case_ : Dict = 1 snake_case_ : Tuple = TFEfficientFormerForImageClassification(lowercase_ ) snake_case_ : Optional[int] = floats_tensor([self.batch_size, 1, self.image_size, self.image_size] ) snake_case_ : str = model(lowercase_ , labels=lowercase_ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.type_sequence_label_size) ) def _snake_case ( self : Tuple ): snake_case_ : Dict = self.prepare_config_and_inputs() snake_case_, snake_case_, snake_case_ : Tuple = config_and_inputs snake_case_ : List[str] = {'''pixel_values''': pixel_values} return config, inputs_dict @require_tf class _UpperCAmelCase ( lowerCAmelCase__ , lowerCAmelCase__ , unittest.TestCase): _lowerCAmelCase : List[str] = ( ( TFEfficientFormerModel, TFEfficientFormerForImageClassificationWithTeacher, TFEfficientFormerForImageClassification, ) if is_tf_available() else () ) _lowerCAmelCase : List[Any] = ( { """feature-extraction""": TFEfficientFormerModel, """image-classification""": ( TFEfficientFormerForImageClassification, TFEfficientFormerForImageClassificationWithTeacher, ), } if is_tf_available() else {} ) _lowerCAmelCase : Optional[Any] = False _lowerCAmelCase : Tuple = False _lowerCAmelCase : Dict = False _lowerCAmelCase : Union[str, Any] = False _lowerCAmelCase : int = False def _snake_case ( self : Optional[int] ): snake_case_ : Optional[Any] = TFEfficientFormerModelTester(self ) snake_case_ : List[str] = ConfigTester( self , config_class=lowercase_ , has_text_modality=lowercase_ , hidden_size=37 ) def _snake_case ( self : Any ): self.config_tester.run_common_tests() @unittest.skip(reason='''EfficientFormer does not use inputs_embeds''' ) def _snake_case ( self : Optional[Any] ): pass @unittest.skip(reason='''EfficientFormer does not support input and output embeddings''' ) def _snake_case ( self : Tuple ): pass def _snake_case ( self : Any ): snake_case_, snake_case_ : Any = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: snake_case_ : int = model_class(lowercase_ ) snake_case_ : Any = inspect.signature(model.call ) # signature.parameters is an OrderedDict => so arg_names order is deterministic snake_case_ : str = [*signature.parameters.keys()] snake_case_ : Dict = ['''pixel_values'''] self.assertListEqual(arg_names[:1] , lowercase_ ) def _snake_case ( self : Tuple ): def check_hidden_states_output(lowercase_ : Optional[int] , lowercase_ : str , lowercase_ : Optional[Any] ): snake_case_ : Any = model_class(lowercase_ ) snake_case_ : Optional[int] = model(**self._prepare_for_class(lowercase_ , lowercase_ ) , training=lowercase_ ) snake_case_ : Optional[int] = outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states snake_case_ : List[str] = getattr( self.model_tester , '''expected_num_hidden_layers''' , self.model_tester.num_hidden_layers + 1 ) self.assertEqual(len(lowercase_ ) , lowercase_ ) if hasattr(self.model_tester , '''encoder_seq_length''' ): snake_case_ : Optional[Any] = self.model_tester.encoder_seq_length if hasattr(self.model_tester , '''chunk_length''' ) and self.model_tester.chunk_length > 1: snake_case_ : Optional[Any] = seq_length * self.model_tester.chunk_length else: snake_case_ : Dict = self.model_tester.seq_length self.assertListEqual( list(hidden_states[-1].shape[-2:] ) , [seq_length, self.model_tester.hidden_size] , ) if config.is_encoder_decoder: snake_case_ : Optional[int] = outputs.decoder_hidden_states self.asseretIsInstance(lowercase_ , (list, tuple) ) self.assertEqual(len(lowercase_ ) , lowercase_ ) snake_case_ : Tuple = getattr(self.model_tester , '''seq_length''' , lowercase_ ) snake_case_ : Any = getattr(self.model_tester , '''decoder_seq_length''' , lowercase_ ) self.assertListEqual( list(hidden_states[-1].shape[-2:] ) , [decoder_seq_length, self.model_tester.hidden_size] , ) snake_case_, snake_case_ : Tuple = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: snake_case_ : List[str] = True check_hidden_states_output(lowercase_ , lowercase_ , lowercase_ ) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] snake_case_ : int = True check_hidden_states_output(lowercase_ , lowercase_ , lowercase_ ) def _snake_case ( self : Union[str, Any] , lowercase_ : Any , lowercase_ : int , lowercase_ : List[str]=False ): snake_case_ : str = super()._prepare_for_class(lowercase_ , lowercase_ , return_labels=lowercase_ ) if return_labels: if model_class.__name__ == "TFEfficientFormerForImageClassificationWithTeacher": del inputs_dict["labels"] return inputs_dict def _snake_case ( self : Tuple ): snake_case_ : Tuple = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*lowercase_ ) @unittest.skip(reason='''EfficientFormer does not implement masked image modeling yet''' ) def _snake_case ( self : Dict ): snake_case_ : Tuple = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_image_modeling(*lowercase_ ) def _snake_case ( self : str ): snake_case_ : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*lowercase_ ) @slow def _snake_case ( self : Union[str, Any] ): for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: snake_case_ : Optional[Any] = TFEfficientFormerModel.from_pretrained(lowercase_ ) self.assertIsNotNone(lowercase_ ) def _snake_case ( self : Dict ): snake_case_, snake_case_ : Dict = self.model_tester.prepare_config_and_inputs_for_common() snake_case_ : str = True snake_case_ : List[str] = getattr(self.model_tester , '''seq_length''' , lowercase_ ) snake_case_ : List[str] = getattr(self.model_tester , '''encoder_seq_length''' , lowercase_ ) snake_case_ : int = getattr(self.model_tester , '''key_length''' , lowercase_ ) snake_case_ : Tuple = getattr(self.model_tester , '''chunk_length''' , lowercase_ ) if chunk_length is not None and hasattr(self.model_tester , '''num_hashes''' ): snake_case_ : List[Any] = encoder_seq_length * self.model_tester.num_hashes for model_class in self.all_model_classes: snake_case_ : int = True snake_case_ : Tuple = False snake_case_ : Union[str, Any] = True snake_case_ : Union[str, Any] = model_class(lowercase_ ) snake_case_ : Optional[Any] = model(**self._prepare_for_class(lowercase_ , lowercase_ ) , training=lowercase_ ) snake_case_ : Optional[Any] = outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions self.assertEqual(len(lowercase_ ) , self.model_tester.num_attention_outputs ) # check that output_attentions also work using config del inputs_dict["output_attentions"] snake_case_ : Dict = True snake_case_ : Optional[int] = model_class(lowercase_ ) snake_case_ : Tuple = model(**self._prepare_for_class(lowercase_ , lowercase_ ) , training=lowercase_ ) snake_case_ : List[str] = outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions self.assertEqual(len(lowercase_ ) , self.model_tester.num_attention_outputs ) if chunk_length is not None: self.assertListEqual( list(attentions[0].shape[-4:] ) , [self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length] , ) else: self.assertListEqual( list(attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length] , ) def _snake_case ( self : List[str] ): # We use a simplified version of this test for EfficientFormer because it requires training=False # and Keras refuses to let us force that during functional construction snake_case_, snake_case_ : Tuple = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: # Prepare our model snake_case_ : Union[str, Any] = model_class(lowercase_ ) # These are maximally general inputs for the model, with multiple None dimensions # Hopefully this will catch any conditionals that fail for flexible shapes snake_case_ : int = { key: tf.keras.Input(shape=val.shape[1:] , dtype=val.dtype , name=lowercase_ ) for key, val in model.input_signature.items() if key in model.dummy_inputs } snake_case_ : Tuple = model(lowercase_ ) self.assertTrue(outputs_dict is not None ) def __lowercase ( ): snake_case_ : Optional[int] = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' ) return image @require_tf @require_vision class _UpperCAmelCase ( unittest.TestCase): @cached_property def _snake_case ( self : List[Any] ): return ( EfficientFormerImageProcessor.from_pretrained('''snap-research/efficientformer-l1-300''' ) if is_vision_available() else None ) @slow def _snake_case ( self : List[str] ): snake_case_ : Optional[int] = TFEfficientFormerForImageClassification.from_pretrained('''snap-research/efficientformer-l1-300''' ) snake_case_ : Dict = self.default_image_processor snake_case_ : List[Any] = prepare_img() snake_case_ : Tuple = image_processor(images=lowercase_ , return_tensors='''tf''' ) # forward pass snake_case_ : int = model(**lowercase_ , training=lowercase_ ) # verify the logits snake_case_ : Any = tf.TensorShape((1, 1000) ) self.assertEqual(outputs.logits.shape , lowercase_ ) snake_case_ : Union[str, Any] = tf.constant([-0.05_55, 0.48_25, -0.08_52] ) self.assertTrue(np.allclose(outputs.logits[0, :3] , lowercase_ , atol=1E-4 ) ) @slow def _snake_case ( self : str ): snake_case_ : str = TFEfficientFormerForImageClassificationWithTeacher.from_pretrained( '''snap-research/efficientformer-l1-300''' ) snake_case_ : Union[str, Any] = self.default_image_processor snake_case_ : Dict = prepare_img() snake_case_ : List[str] = image_processor(images=lowercase_ , return_tensors='''tf''' ) # forward pass snake_case_ : Union[str, Any] = model(**lowercase_ , training=lowercase_ ) # verify the logits snake_case_ : Tuple = tf.TensorShape((1, 1000) ) self.assertEqual(outputs.logits.shape , lowercase_ ) snake_case_ : Dict = tf.constant([-0.13_12, 0.43_53, -1.04_99] ) self.assertTrue(np.allclose(outputs.logits[0, :3] , lowercase_ , atol=1E-4 ) )

"""simple docstring""" from collections import OrderedDict from typing import Mapping from packaging import version from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging from ..auto import CONFIG_MAPPING lowercase__ : List[str] = logging.get_logger(__name__) lowercase__ : List[Any] = { '''microsoft/table-transformer-detection''': ( '''https://huggingface.co/microsoft/table-transformer-detection/resolve/main/config.json''' ), } class _UpperCAmelCase ( lowerCAmelCase__): _lowerCAmelCase : Optional[Any] = """table-transformer""" _lowerCAmelCase : Any = ["""past_key_values"""] _lowerCAmelCase : Union[str, Any] = { """hidden_size""": """d_model""", """num_attention_heads""": """encoder_attention_heads""", } def __init__( self : Any , lowercase_ : Any=True , lowercase_ : Dict=None , lowercase_ : Optional[int]=3 , lowercase_ : Any=100 , lowercase_ : List[str]=6 , lowercase_ : Any=2048 , lowercase_ : Any=8 , lowercase_ : Tuple=6 , lowercase_ : List[Any]=2048 , lowercase_ : List[str]=8 , lowercase_ : List[Any]=0.0 , lowercase_ : str=0.0 , lowercase_ : Dict=True , lowercase_ : Optional[int]="relu" , lowercase_ : Dict=256 , lowercase_ : Optional[int]=0.1 , lowercase_ : List[Any]=0.0 , lowercase_ : List[str]=0.0 , lowercase_ : Dict=0.02 , lowercase_ : int=1.0 , lowercase_ : Tuple=False , lowercase_ : Optional[Any]="sine" , lowercase_ : Union[str, Any]="resnet50" , lowercase_ : List[Any]=True , lowercase_ : List[Any]=False , lowercase_ : Optional[Any]=1 , lowercase_ : Dict=5 , lowercase_ : List[Any]=2 , lowercase_ : Tuple=1 , lowercase_ : List[Any]=1 , lowercase_ : Dict=5 , lowercase_ : Union[str, Any]=2 , lowercase_ : Union[str, Any]=0.1 , **lowercase_ : int , ): if backbone_config is not None and use_timm_backbone: raise ValueError('''You can\'t specify both `backbone_config` and `use_timm_backbone`.''' ) if not use_timm_backbone: if backbone_config is None: logger.info('''`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.''' ) snake_case_ : Dict = CONFIG_MAPPING['''resnet'''](out_features=['''stage4'''] ) elif isinstance(lowercase_ , lowercase_ ): snake_case_ : List[Any] = backbone_config.get('''model_type''' ) snake_case_ : int = CONFIG_MAPPING[backbone_model_type] snake_case_ : List[str] = config_class.from_dict(lowercase_ ) # set timm attributes to None snake_case_, snake_case_, snake_case_ : List[str] = None, None, None snake_case_ : Tuple = use_timm_backbone snake_case_ : int = backbone_config snake_case_ : str = num_channels snake_case_ : List[str] = num_queries snake_case_ : int = d_model snake_case_ : List[str] = encoder_ffn_dim snake_case_ : Any = encoder_layers snake_case_ : List[Any] = encoder_attention_heads snake_case_ : Optional[int] = decoder_ffn_dim snake_case_ : Tuple = decoder_layers snake_case_ : List[str] = decoder_attention_heads snake_case_ : Tuple = dropout snake_case_ : Union[str, Any] = attention_dropout snake_case_ : Dict = activation_dropout snake_case_ : Optional[Any] = activation_function snake_case_ : Optional[Any] = init_std snake_case_ : str = init_xavier_std snake_case_ : Any = encoder_layerdrop snake_case_ : Optional[Any] = decoder_layerdrop snake_case_ : List[str] = encoder_layers snake_case_ : Optional[int] = auxiliary_loss snake_case_ : List[Any] = position_embedding_type snake_case_ : List[Any] = backbone snake_case_ : Union[str, Any] = use_pretrained_backbone snake_case_ : Optional[Any] = dilation # Hungarian matcher snake_case_ : Tuple = class_cost snake_case_ : Any = bbox_cost snake_case_ : Dict = giou_cost # Loss coefficients snake_case_ : Optional[Any] = mask_loss_coefficient snake_case_ : str = dice_loss_coefficient snake_case_ : List[str] = bbox_loss_coefficient snake_case_ : int = giou_loss_coefficient snake_case_ : Optional[Any] = eos_coefficient super().__init__(is_encoder_decoder=lowercase_ , **lowercase_ ) @property def _snake_case ( self : Optional[int] ): return self.encoder_attention_heads @property def _snake_case ( self : Any ): return self.d_model class _UpperCAmelCase ( lowerCAmelCase__): _lowerCAmelCase : List[Any] = version.parse("""1.11""") @property def _snake_case ( self : List[Any] ): return OrderedDict( [ ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}), ('''pixel_mask''', {0: '''batch'''}), ] ) @property def _snake_case ( self : int ): return 1E-5 @property def _snake_case ( self : Optional[int] ): return 12

"""simple docstring""" # This model implementation is heavily inspired by https://github.com/haofanwang/ControlNet-for-Diffusers/ import gc import random import tempfile import unittest import numpy as np import torch from PIL import Image from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer from diffusers import ( AutoencoderKL, ControlNetModel, DDIMScheduler, StableDiffusionControlNetImgaImgPipeline, UNetaDConditionModel, ) from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device from diffusers.utils.import_utils import is_xformers_available from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu from ..pipeline_params import ( IMAGE_TO_IMAGE_IMAGE_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS, ) from ..test_pipelines_common import ( PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin, ) enable_full_determinism() class _UpperCAmelCase ( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , unittest.TestCase ): '''simple docstring''' lowercase_ : List[Any] = StableDiffusionControlNetImgaImgPipeline lowercase_ : Optional[int] = TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""height""", """width"""} lowercase_ : Optional[int] = TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS lowercase_ : Dict = IMAGE_TO_IMAGE_IMAGE_PARAMS.union({"""control_image"""} ) lowercase_ : Any = IMAGE_TO_IMAGE_IMAGE_PARAMS def lowerCamelCase_ ( self ): """simple docstring""" torch.manual_seed(0 ) A_ : Tuple = UNetaDConditionModel( block_out_channels=(3_2, 6_4) , layers_per_block=2 , sample_size=3_2 , in_channels=4 , out_channels=4 , down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D') , up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D') , cross_attention_dim=3_2 , ) torch.manual_seed(0 ) A_ : Dict = ControlNetModel( block_out_channels=(3_2, 6_4) , layers_per_block=2 , in_channels=4 , down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D') , cross_attention_dim=3_2 , conditioning_embedding_out_channels=(1_6, 3_2) , ) torch.manual_seed(0 ) A_ : Dict = DDIMScheduler( beta_start=0.0_00_85 , beta_end=0.0_12 , beta_schedule='scaled_linear' , clip_sample=_lowercase , set_alpha_to_one=_lowercase , ) torch.manual_seed(0 ) A_ : List[str] = AutoencoderKL( block_out_channels=[3_2, 6_4] , in_channels=3 , out_channels=3 , down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'] , up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'] , latent_channels=4 , ) torch.manual_seed(0 ) A_ : List[str] = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=3_2 , intermediate_size=3_7 , layer_norm_eps=1E-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1_0_0_0 , ) A_ : Tuple = CLIPTextModel(_lowercase ) A_ : Optional[int] = CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' ) A_ : List[str] = { 'unet': unet, 'controlnet': controlnet, 'scheduler': scheduler, 'vae': vae, 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'safety_checker': None, 'feature_extractor': None, } return components def lowerCamelCase_ ( self , snake_case_ , snake_case_=0 ): """simple docstring""" if str(_lowercase ).startswith('mps' ): A_ : Optional[Any] = torch.manual_seed(_lowercase ) else: A_ : Union[str, Any] = torch.Generator(device=_lowercase ).manual_seed(_lowercase ) A_ : Optional[Any] = 2 A_ : Tuple = randn_tensor( (1, 3, 3_2 * controlnet_embedder_scale_factor, 3_2 * controlnet_embedder_scale_factor) , generator=_lowercase , device=torch.device(_lowercase ) , ) A_ : Union[str, Any] = floats_tensor(control_image.shape , rng=random.Random(_lowercase ) ).to(_lowercase ) A_ : Dict = image.cpu().permute(0 , 2 , 3 , 1 )[0] A_ : List[Any] = Image.fromarray(np.uinta(_lowercase ) ).convert('RGB' ).resize((6_4, 6_4) ) A_ : Any = { 'prompt': 'A painting of a squirrel eating a burger', 'generator': generator, 'num_inference_steps': 2, 'guidance_scale': 6.0, 'output_type': 'numpy', 'image': image, 'control_image': control_image, } return inputs def lowerCamelCase_ ( self ): """simple docstring""" return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3 ) @unittest.skipIf( torch_device != 'cuda' or not is_xformers_available() , reason='XFormers attention is only available with CUDA and `xformers` installed' , ) def lowerCamelCase_ ( self ): """simple docstring""" self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3 ) def lowerCamelCase_ ( self ): """simple docstring""" self._test_inference_batch_single_identical(expected_max_diff=2E-3 ) class _UpperCAmelCase ( lowerCamelCase_ , lowerCamelCase_ , unittest.TestCase ): '''simple docstring''' lowercase_ : str = StableDiffusionControlNetImgaImgPipeline lowercase_ : List[str] = TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""height""", """width"""} lowercase_ : int = TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS lowercase_ : Any = frozenset([] ) # TO_DO: add image_params once refactored VaeImageProcessor.preprocess def lowerCamelCase_ ( self ): """simple docstring""" torch.manual_seed(0 ) A_ : Union[str, Any] = UNetaDConditionModel( block_out_channels=(3_2, 6_4) , layers_per_block=2 , sample_size=3_2 , in_channels=4 , out_channels=4 , down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D') , up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D') , cross_attention_dim=3_2 , ) torch.manual_seed(0 ) def init_weights(snake_case_ ): if isinstance(_lowercase , torch.nn.Convad ): torch.nn.init.normal(m.weight ) m.bias.data.fill_(1.0 ) A_ : Dict = ControlNetModel( block_out_channels=(3_2, 6_4) , layers_per_block=2 , in_channels=4 , down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D') , cross_attention_dim=3_2 , conditioning_embedding_out_channels=(1_6, 3_2) , ) controlneta.controlnet_down_blocks.apply(_lowercase ) torch.manual_seed(0 ) A_ : str = ControlNetModel( block_out_channels=(3_2, 6_4) , layers_per_block=2 , in_channels=4 , down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D') , cross_attention_dim=3_2 , conditioning_embedding_out_channels=(1_6, 3_2) , ) controlneta.controlnet_down_blocks.apply(_lowercase ) torch.manual_seed(0 ) A_ : Optional[Any] = DDIMScheduler( beta_start=0.0_00_85 , beta_end=0.0_12 , beta_schedule='scaled_linear' , clip_sample=_lowercase , set_alpha_to_one=_lowercase , ) torch.manual_seed(0 ) A_ : Dict = AutoencoderKL( block_out_channels=[3_2, 6_4] , in_channels=3 , out_channels=3 , down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'] , up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'] , latent_channels=4 , ) torch.manual_seed(0 ) A_ : List[Any] = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=3_2 , intermediate_size=3_7 , layer_norm_eps=1E-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1_0_0_0 , ) A_ : Optional[Any] = CLIPTextModel(_lowercase ) A_ : List[str] = CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' ) A_ : List[str] = MultiControlNetModel([controlneta, controlneta] ) A_ : List[str] = { 'unet': unet, 'controlnet': controlnet, 'scheduler': scheduler, 'vae': vae, 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'safety_checker': None, 'feature_extractor': None, } return components def lowerCamelCase_ ( self , snake_case_ , snake_case_=0 ): """simple docstring""" if str(_lowercase ).startswith('mps' ): A_ : Optional[int] = torch.manual_seed(_lowercase ) else: A_ : Optional[int] = torch.Generator(device=_lowercase ).manual_seed(_lowercase ) A_ : int = 2 A_ : List[str] = [ randn_tensor( (1, 3, 3_2 * controlnet_embedder_scale_factor, 3_2 * controlnet_embedder_scale_factor) , generator=_lowercase , device=torch.device(_lowercase ) , ), randn_tensor( (1, 3, 3_2 * controlnet_embedder_scale_factor, 3_2 * controlnet_embedder_scale_factor) , generator=_lowercase , device=torch.device(_lowercase ) , ), ] A_ : Any = floats_tensor(control_image[0].shape , rng=random.Random(_lowercase ) ).to(_lowercase ) A_ : str = image.cpu().permute(0 , 2 , 3 , 1 )[0] A_ : Optional[int] = Image.fromarray(np.uinta(_lowercase ) ).convert('RGB' ).resize((6_4, 6_4) ) A_ : int = { 'prompt': 'A painting of a squirrel eating a burger', 'generator': generator, 'num_inference_steps': 2, 'guidance_scale': 6.0, 'output_type': 'numpy', 'image': image, 'control_image': control_image, } return inputs def lowerCamelCase_ ( self ): """simple docstring""" A_ : str = self.get_dummy_components() A_ : Dict = self.pipeline_class(**_lowercase ) pipe.to(_lowercase ) A_ : int = 10.0 A_ : List[Any] = 4 A_ : List[Any] = self.get_dummy_inputs(_lowercase ) A_ : Any = steps A_ : Union[str, Any] = scale A_ : Union[str, Any] = pipe(**_lowercase )[0] A_ : Dict = self.get_dummy_inputs(_lowercase ) A_ : Optional[Any] = steps A_ : Any = scale A_ : List[str] = pipe(**_lowercase , control_guidance_start=0.1 , control_guidance_end=0.2 )[0] A_ : Optional[int] = self.get_dummy_inputs(_lowercase ) A_ : int = steps A_ : List[str] = scale A_ : Dict = pipe(**_lowercase , control_guidance_start=[0.1, 0.3] , control_guidance_end=[0.2, 0.7] )[0] A_ : int = self.get_dummy_inputs(_lowercase ) A_ : Optional[int] = steps A_ : str = scale A_ : Union[str, Any] = pipe(**_lowercase , control_guidance_start=0.4 , control_guidance_end=[0.5, 0.8] )[0] # make sure that all outputs are different assert np.sum(np.abs(output_a - output_a ) ) > 1E-3 assert np.sum(np.abs(output_a - output_a ) ) > 1E-3 assert np.sum(np.abs(output_a - output_a ) ) > 1E-3 def lowerCamelCase_ ( self ): """simple docstring""" return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3 ) @unittest.skipIf( torch_device != 'cuda' or not is_xformers_available() , reason='XFormers attention is only available with CUDA and `xformers` installed' , ) def lowerCamelCase_ ( self ): """simple docstring""" self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3 ) def lowerCamelCase_ ( self ): """simple docstring""" self._test_inference_batch_single_identical(expected_max_diff=2E-3 ) def lowerCamelCase_ ( self ): """simple docstring""" A_ : Tuple = self.get_dummy_components() A_ : Union[str, Any] = self.pipeline_class(**_lowercase ) pipe.to(_lowercase ) pipe.set_progress_bar_config(disable=_lowercase ) with tempfile.TemporaryDirectory() as tmpdir: try: # save_pretrained is not implemented for Multi-ControlNet pipe.save_pretrained(_lowercase ) except NotImplementedError: pass @slow @require_torch_gpu class _UpperCAmelCase ( unittest.TestCase ): '''simple docstring''' def lowerCamelCase_ ( self ): """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def lowerCamelCase_ ( self ): """simple docstring""" A_ : Optional[int] = ControlNetModel.from_pretrained('lllyasviel/sd-controlnet-canny' ) A_ : List[Any] = StableDiffusionControlNetImgaImgPipeline.from_pretrained( 'runwayml/stable-diffusion-v1-5' , safety_checker=_lowercase , controlnet=_lowercase ) pipe.enable_model_cpu_offload() pipe.set_progress_bar_config(disable=_lowercase ) A_ : List[str] = torch.Generator(device='cpu' ).manual_seed(0 ) A_ : Dict = 'evil space-punk bird' A_ : List[str] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png' ).resize((5_1_2, 5_1_2) ) A_ : List[Any] = load_image( 'https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png' ).resize((5_1_2, 5_1_2) ) A_ : List[str] = pipe( _lowercase , _lowercase , control_image=_lowercase , generator=_lowercase , output_type='np' , num_inference_steps=5_0 , strength=0.6 , ) A_ : List[Any] = output.images[0] assert image.shape == (5_1_2, 5_1_2, 3) A_ : Union[str, Any] = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/img2img.npy' ) assert np.abs(expected_image - image ).max() < 9E-2

from datetime import datetime import requests from bsa import BeautifulSoup if __name__ == "__main__": __lowerCamelCase : str = input('''Enter image url: ''').strip() print(F"""Downloading image from {url} ...""") __lowerCamelCase : 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 __lowerCamelCase : List[Any] = soup.find('''meta''', {'''property''': '''og:image'''})['''content'''] __lowerCamelCase : Tuple = requests.get(image_url).content __lowerCamelCase : Union[str, 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}.""")

from math import atan, cos, radians, sin, tan from .haversine_distance import haversine_distance UpperCAmelCase__ = 637_8137.0 UpperCAmelCase__ = 635_6752.31_4245 UpperCAmelCase__ = 6378137 def _a ( a :float , a :float , a :float , a :float ) -> float: a = (AXIS_A - AXIS_B) / AXIS_A # Parametric latitudes # https://en.wikipedia.org/wiki/Latitude#Parametric_(or_reduced)_latitude a = atan((1 - flattening) * tan(radians(a ) ) ) a = atan((1 - flattening) * tan(radians(a ) ) ) # Compute central angle between two points # using haversine theta. sigma = haversine_distance / equatorial radius a = haversine_distance(a , a , a , a ) / EQUATORIAL_RADIUS # Intermediate P and Q values a = (b_lata + b_lata) / 2 a = (b_lata - b_lata) / 2 # Intermediate X value # X = (sigma - sin(sigma)) * sin^2Pcos^2Q / cos^2(sigma/2) a = (sin(a ) ** 2) * (cos(a ) ** 2) a = cos(sigma / 2 ) ** 2 a = (sigma - sin(a )) * (x_numerator / x_demonimator) # Intermediate Y value # Y = (sigma + sin(sigma)) * cos^2Psin^2Q / sin^2(sigma/2) a = (cos(a ) ** 2) * (sin(a ) ** 2) a = sin(sigma / 2 ) ** 2 a = (sigma + sin(a )) * (y_numerator / y_denominator) return EQUATORIAL_RADIUS * (sigma - ((flattening / 2) * (x_value + y_value))) if __name__ == "__main__": import doctest doctest.testmod()

import shutil import tempfile import unittest import numpy as np import pytest from transformers.testing_utils import require_vision from transformers.utils import is_vision_available if is_vision_available(): from PIL import Image from transformers import ( AutoProcessor, BertTokenizerFast, BlipImageProcessor, GPTaTokenizer, InstructBlipProcessor, PreTrainedTokenizerFast, ) @require_vision class lowercase_ ( unittest.TestCase ): '''simple docstring''' def __lowerCAmelCase ( self : Optional[int] ) ->Tuple: """simple docstring""" a = tempfile.mkdtemp() a = BlipImageProcessor() a = GPTaTokenizer.from_pretrained('''hf-internal-testing/tiny-random-GPT2Model''' ) a = BertTokenizerFast.from_pretrained('''hf-internal-testing/tiny-random-bert''' ) a = InstructBlipProcessor(__UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase ) processor.save_pretrained(self.tmpdirname ) def __lowerCAmelCase ( self : Optional[Any] , **__UpperCAmelCase : Tuple ) ->List[str]: """simple docstring""" return AutoProcessor.from_pretrained(self.tmpdirname , **__UpperCAmelCase ).tokenizer def __lowerCAmelCase ( self : int , **__UpperCAmelCase : str ) ->List[str]: """simple docstring""" return AutoProcessor.from_pretrained(self.tmpdirname , **__UpperCAmelCase ).image_processor def __lowerCAmelCase ( self : Optional[Any] , **__UpperCAmelCase : Any ) ->Optional[Any]: """simple docstring""" return AutoProcessor.from_pretrained(self.tmpdirname , **__UpperCAmelCase ).qformer_tokenizer def __lowerCAmelCase ( self : str ) ->Tuple: """simple docstring""" shutil.rmtree(self.tmpdirname ) def __lowerCAmelCase ( self : Optional[int] ) ->str: """simple docstring""" a = [np.random.randint(255 , size=(3, 30, 400) , dtype=np.uinta )] a = [Image.fromarray(np.moveaxis(__UpperCAmelCase , 0 , -1 ) ) for x in image_inputs] return image_inputs def __lowerCAmelCase ( self : Optional[Any] ) ->List[str]: """simple docstring""" a = InstructBlipProcessor( tokenizer=self.get_tokenizer() , image_processor=self.get_image_processor() , qformer_tokenizer=self.get_qformer_tokenizer() , ) processor.save_pretrained(self.tmpdirname ) a = self.get_tokenizer(bos_token='''(BOS)''' , eos_token='''(EOS)''' ) a = self.get_image_processor(do_normalize=__UpperCAmelCase , padding_value=1.0 ) a = InstructBlipProcessor.from_pretrained( self.tmpdirname , bos_token='''(BOS)''' , eos_token='''(EOS)''' , do_normalize=__UpperCAmelCase , padding_value=1.0 ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.tokenizer , __UpperCAmelCase ) self.assertEqual(processor.image_processor.to_json_string() , image_processor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.image_processor , __UpperCAmelCase ) self.assertIsInstance(processor.qformer_tokenizer , __UpperCAmelCase ) def __lowerCAmelCase ( self : Optional[Any] ) ->Any: """simple docstring""" a = self.get_image_processor() a = self.get_tokenizer() a = self.get_qformer_tokenizer() a = InstructBlipProcessor( tokenizer=__UpperCAmelCase , image_processor=__UpperCAmelCase , qformer_tokenizer=__UpperCAmelCase ) a = self.prepare_image_inputs() a = image_processor(__UpperCAmelCase , return_tensors='''np''' ) a = processor(images=__UpperCAmelCase , 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 __lowerCAmelCase ( self : List[str] ) ->List[Any]: """simple docstring""" a = self.get_image_processor() a = self.get_tokenizer() a = self.get_qformer_tokenizer() a = InstructBlipProcessor( tokenizer=__UpperCAmelCase , image_processor=__UpperCAmelCase , qformer_tokenizer=__UpperCAmelCase ) a = '''lower newer''' a = processor(text=__UpperCAmelCase ) a = tokenizer(__UpperCAmelCase , return_token_type_ids=__UpperCAmelCase ) a = qformer_tokenizer(__UpperCAmelCase , return_token_type_ids=__UpperCAmelCase ) for key in encoded_tokens.keys(): self.assertListEqual(encoded_tokens[key] , encoded_processor[key] ) for key in encoded_tokens_qformer.keys(): self.assertListEqual(encoded_tokens_qformer[key] , encoded_processor['''qformer_''' + key] ) def __lowerCAmelCase ( self : Dict ) ->Optional[Any]: """simple docstring""" a = self.get_image_processor() a = self.get_tokenizer() a = self.get_qformer_tokenizer() a = InstructBlipProcessor( tokenizer=__UpperCAmelCase , image_processor=__UpperCAmelCase , qformer_tokenizer=__UpperCAmelCase ) a = '''lower newer''' a = self.prepare_image_inputs() a = processor(text=__UpperCAmelCase , images=__UpperCAmelCase ) self.assertListEqual( list(inputs.keys() ) , ['''input_ids''', '''attention_mask''', '''qformer_input_ids''', '''qformer_attention_mask''', '''pixel_values'''] , ) # test if it raises when no input is passed with pytest.raises(__UpperCAmelCase ): processor() def __lowerCAmelCase ( self : Dict ) ->List[Any]: """simple docstring""" a = self.get_image_processor() a = self.get_tokenizer() a = self.get_qformer_tokenizer() a = InstructBlipProcessor( tokenizer=__UpperCAmelCase , image_processor=__UpperCAmelCase , qformer_tokenizer=__UpperCAmelCase ) a = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] a = processor.batch_decode(__UpperCAmelCase ) a = tokenizer.batch_decode(__UpperCAmelCase ) self.assertListEqual(__UpperCAmelCase , __UpperCAmelCase ) def __lowerCAmelCase ( self : Union[str, Any] ) ->str: """simple docstring""" a = self.get_image_processor() a = self.get_tokenizer() a = self.get_qformer_tokenizer() a = InstructBlipProcessor( tokenizer=__UpperCAmelCase , image_processor=__UpperCAmelCase , qformer_tokenizer=__UpperCAmelCase ) a = '''lower newer''' a = self.prepare_image_inputs() a = processor(text=__UpperCAmelCase , images=__UpperCAmelCase ) self.assertListEqual( list(inputs.keys() ) , ['''input_ids''', '''attention_mask''', '''qformer_input_ids''', '''qformer_attention_mask''', '''pixel_values'''] , )

'''simple docstring''' import warnings from typing import Dict import numpy as np from ..utils import ExplicitEnum, add_end_docstrings, is_tf_available, is_torch_available from .base import PIPELINE_INIT_ARGS, GenericTensor, Pipeline if is_tf_available(): from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING def lowerCAmelCase_ ( snake_case_ : Optional[int] ) -> str: '''simple docstring''' return 1.0 / (1.0 + np.exp(-_outputs )) def lowerCAmelCase_ ( snake_case_ : Optional[int] ) -> Dict: '''simple docstring''' UpperCAmelCase_ = np.max(_outputs , axis=-1 , keepdims=snake_case_ ) UpperCAmelCase_ = np.exp(_outputs - maxes ) return shifted_exp / shifted_exp.sum(axis=-1 , keepdims=snake_case_ ) class __A ( UpperCamelCase__ ): a__ : List[str] = """sigmoid""" a__ : Tuple = """softmax""" a__ : Union[str, Any] = """none""" @add_end_docstrings( UpperCamelCase__ , r""" return_all_scores (`bool`, *optional*, defaults to `False`): Whether to return all prediction scores or just the one of the predicted class. function_to_apply (`str`, *optional*, defaults to `\"default\"`): The function to apply to the model outputs in order to retrieve the scores. Accepts four different values: - `\"default\"`: if the model has a single label, will apply the sigmoid function on the output. If the model has several labels, will apply the softmax function on the output. - `\"sigmoid\"`: Applies the sigmoid function on the output. - `\"softmax\"`: Applies the softmax function on the output. - `\"none\"`: Does not apply any function on the output. """ , ) class __A ( UpperCamelCase__ ): a__ : Optional[Any] = False a__ : List[str] = ClassificationFunction.NONE def __init__(self : Dict , **__a : Any ): super().__init__(**__a ) self.check_model_type( TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING if self.framework == "tf" else MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING ) def _lowercase (self : Dict , __a : Dict=None , __a : Any=None , __a : int="" , **__a : Dict ): # Using "" as default argument because we're going to use `top_k=None` in user code to declare # "No top_k" UpperCAmelCase_ = tokenizer_kwargs UpperCAmelCase_ = {} if hasattr(self.model.config , "return_all_scores" ) and return_all_scores is None: UpperCAmelCase_ = self.model.config.return_all_scores if isinstance(__a , __a ) or top_k is None: UpperCAmelCase_ = top_k UpperCAmelCase_ = False elif return_all_scores is not None: warnings.warn( "`return_all_scores` is now deprecated, if want a similar functionality use `top_k=None` instead of" " `return_all_scores=True` or `top_k=1` instead of `return_all_scores=False`." , __a , ) if return_all_scores: UpperCAmelCase_ = None else: UpperCAmelCase_ = 1 if isinstance(__a , __a ): UpperCAmelCase_ = ClassificationFunction[function_to_apply.upper()] if function_to_apply is not None: UpperCAmelCase_ = function_to_apply return preprocess_params, {}, postprocess_params def __call__(self : Optional[int] , *__a : List[Any] , **__a : Tuple ): UpperCAmelCase_ = super().__call__(*__a , **__a ) # TODO try and retrieve it in a nicer way from _sanitize_parameters. UpperCAmelCase_ = "top_k" not in kwargs if isinstance(args[0] , __a ) and _legacy: # This pipeline is odd, and return a list when single item is run return [result] else: return result def _lowercase (self : Optional[Any] , __a : Dict , **__a : List[str] ): UpperCAmelCase_ = self.framework if isinstance(__a , __a ): return self.tokenizer(**__a , return_tensors=__a , **__a ) elif isinstance(__a , __a ) and len(__a ) == 1 and isinstance(inputs[0] , __a ) and len(inputs[0] ) == 2: # It used to be valid to use a list of list of list for text pairs, keeping this path for BC return self.tokenizer( text=inputs[0][0] , text_pair=inputs[0][1] , return_tensors=__a , **__a ) elif isinstance(__a , __a ): # This is likely an invalid usage of the pipeline attempting to pass text pairs. raise ValueError( "The pipeline received invalid inputs, if you are trying to send text pairs, you can try to send a" " dictionary `{\"text\": \"My text\", \"text_pair\": \"My pair\"}` in order to send a text pair." ) return self.tokenizer(__a , return_tensors=__a , **__a ) def _lowercase (self : Dict , __a : Optional[Any] ): return self.model(**__a ) def _lowercase (self : Dict , __a : int , __a : int=None , __a : List[str]=1 , __a : List[str]=True ): # `_legacy` is used to determine if we're running the naked pipeline and in backward # compatibility mode, or if running the pipeline with `pipeline(..., top_k=1)` we're running # the more natural result containing the list. # Default value before `set_parameters` if function_to_apply is None: if self.model.config.problem_type == "multi_label_classification" or self.model.config.num_labels == 1: UpperCAmelCase_ = ClassificationFunction.SIGMOID elif self.model.config.problem_type == "single_label_classification" or self.model.config.num_labels > 1: UpperCAmelCase_ = ClassificationFunction.SOFTMAX elif hasattr(self.model.config , "function_to_apply" ) and function_to_apply is None: UpperCAmelCase_ = self.model.config.function_to_apply else: UpperCAmelCase_ = ClassificationFunction.NONE UpperCAmelCase_ = model_outputs["logits"][0] UpperCAmelCase_ = outputs.numpy() if function_to_apply == ClassificationFunction.SIGMOID: UpperCAmelCase_ = sigmoid(__a ) elif function_to_apply == ClassificationFunction.SOFTMAX: UpperCAmelCase_ = softmax(__a ) elif function_to_apply == ClassificationFunction.NONE: UpperCAmelCase_ = outputs else: raise ValueError(f"""Unrecognized `function_to_apply` argument: {function_to_apply}""" ) if top_k == 1 and _legacy: return {"label": self.model.config.idalabel[scores.argmax().item()], "score": scores.max().item()} UpperCAmelCase_ = [ {"label": self.model.config.idalabel[i], "score": score.item()} for i, score in enumerate(__a ) ] if not _legacy: dict_scores.sort(key=lambda __a : x["score"] , reverse=__a ) if top_k is not None: UpperCAmelCase_ = dict_scores[:top_k] return dict_scores

'''simple docstring''' from typing import TYPE_CHECKING # rely on isort to merge the imports from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available UpperCamelCase = {'''configuration_focalnet''': ['''FOCALNET_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''FocalNetConfig''']} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCamelCase = [ '''FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST''', '''FocalNetForImageClassification''', '''FocalNetForMaskedImageModeling''', '''FocalNetBackbone''', '''FocalNetModel''', '''FocalNetPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_focalnet import FOCALNET_PRETRAINED_CONFIG_ARCHIVE_MAP, FocalNetConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_focalnet import ( FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST, FocalNetBackbone, FocalNetForImageClassification, FocalNetForMaskedImageModeling, FocalNetModel, FocalNetPreTrainedModel, ) else: import sys UpperCamelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

"""simple docstring""" import copy from ...configuration_utils import PretrainedConfig from ...utils import logging from ..auto.configuration_auto import CONFIG_MAPPING UpperCamelCase = logging.get_logger(__name__) class __UpperCAmelCase (__a ): __snake_case : List[Any] = """upernet""" def __init__( self: Optional[int] , UpperCAmelCase_: Optional[int]=None , UpperCAmelCase_: List[str]=512 , UpperCAmelCase_: Dict=0.02 , UpperCAmelCase_: Optional[Any]=[1, 2, 3, 6] , UpperCAmelCase_: Optional[int]=True , UpperCAmelCase_: Dict=0.4 , UpperCAmelCase_: Tuple=384 , UpperCAmelCase_: Optional[Any]=256 , UpperCAmelCase_: Dict=1 , UpperCAmelCase_: int=False , UpperCAmelCase_: List[str]=255 , **UpperCAmelCase_: List[str] , ): '''simple docstring''' super().__init__(**a__ ) if backbone_config is None: logger.info("""`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.""" ) _SCREAMING_SNAKE_CASE = CONFIG_MAPPING["""resnet"""](out_features=["""stage1""", """stage2""", """stage3""", """stage4"""] ) elif isinstance(a__ , a__ ): _SCREAMING_SNAKE_CASE = backbone_config.get("""model_type""" ) _SCREAMING_SNAKE_CASE = CONFIG_MAPPING[backbone_model_type] _SCREAMING_SNAKE_CASE = config_class.from_dict(a__ ) _SCREAMING_SNAKE_CASE = backbone_config _SCREAMING_SNAKE_CASE = hidden_size _SCREAMING_SNAKE_CASE = initializer_range _SCREAMING_SNAKE_CASE = pool_scales _SCREAMING_SNAKE_CASE = use_auxiliary_head _SCREAMING_SNAKE_CASE = auxiliary_loss_weight _SCREAMING_SNAKE_CASE = auxiliary_in_channels _SCREAMING_SNAKE_CASE = auxiliary_channels _SCREAMING_SNAKE_CASE = auxiliary_num_convs _SCREAMING_SNAKE_CASE = auxiliary_concat_input _SCREAMING_SNAKE_CASE = loss_ignore_index def UpperCamelCase ( self: Tuple ): '''simple docstring''' _SCREAMING_SNAKE_CASE = copy.deepcopy(self.__dict__ ) _SCREAMING_SNAKE_CASE = self.backbone_config.to_dict() _SCREAMING_SNAKE_CASE = self.__class__.model_type return output

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 = None UpperCamelCase = logging.get_logger(__name__) UpperCamelCase = {'''vocab_file''': '''sentencepiece.bpe.model''', '''tokenizer_file''': '''tokenizer.json'''} UpperCamelCase = { '''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 = { '''camembert-base''': 512, } UpperCamelCase = '''▁''' class __UpperCAmelCase (_UpperCAmelCase ): __snake_case : int = VOCAB_FILES_NAMES __snake_case : Any = PRETRAINED_VOCAB_FILES_MAP __snake_case : Optional[Any] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES __snake_case : Dict = ["input_ids", "attention_mask"] __snake_case : Tuple = CamembertTokenizer def __init__( self: List[Any] , UpperCAmelCase_: Optional[int]=None , UpperCAmelCase_: Tuple=None , UpperCAmelCase_: str="<s>" , UpperCAmelCase_: List[str]="</s>" , UpperCAmelCase_: Dict="</s>" , UpperCAmelCase_: List[Any]="<s>" , UpperCAmelCase_: Dict="<unk>" , UpperCAmelCase_: Any="<pad>" , UpperCAmelCase_: Tuple="<mask>" , UpperCAmelCase_: str=["<s>NOTUSED", "</s>NOTUSED"] , **UpperCAmelCase_: Optional[Any] , ): '''simple docstring''' _SCREAMING_SNAKE_CASE = AddedToken(UpperCAmelCase_ , lstrip=UpperCAmelCase_ , rstrip=UpperCAmelCase_ ) if isinstance(UpperCAmelCase_ , UpperCAmelCase_ ) else mask_token super().__init__( UpperCAmelCase_ , tokenizer_file=UpperCAmelCase_ , bos_token=UpperCAmelCase_ , eos_token=UpperCAmelCase_ , sep_token=UpperCAmelCase_ , cls_token=UpperCAmelCase_ , unk_token=UpperCAmelCase_ , pad_token=UpperCAmelCase_ , mask_token=UpperCAmelCase_ , additional_special_tokens=UpperCAmelCase_ , **UpperCAmelCase_ , ) _SCREAMING_SNAKE_CASE = vocab_file _SCREAMING_SNAKE_CASE = False if not self.vocab_file else True def UpperCamelCase ( self: int , UpperCAmelCase_: List[int] , UpperCAmelCase_: 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 = [self.cls_token_id] _SCREAMING_SNAKE_CASE = [self.sep_token_id] return cls + token_ids_a + sep + sep + token_ids_a + sep def UpperCamelCase ( self: List[str] , UpperCAmelCase_: List[int] , UpperCAmelCase_: Optional[List[int]] = None ): '''simple docstring''' _SCREAMING_SNAKE_CASE = [self.sep_token_id] _SCREAMING_SNAKE_CASE = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0] def UpperCamelCase ( self: List[str] , UpperCAmelCase_: str , UpperCAmelCase_: 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(UpperCAmelCase_ ): logger.error(F'Vocabulary path ({save_directory}) should be a directory' ) return _SCREAMING_SNAKE_CASE = os.path.join( UpperCAmelCase_ , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(UpperCAmelCase_ ): copyfile(self.vocab_file , UpperCAmelCase_ ) return (out_vocab_file,)

"""simple docstring""" from __future__ import annotations __lowerCAmelCase : str =8.988E9 # units = N * m^s * C^-2 def UpperCAmelCase__ ( lowerCAmelCase__ :Dict , lowerCAmelCase__ :Optional[Any] , lowerCAmelCase__ :int , lowerCAmelCase__ :Optional[Any] ) -> dict[str, float]: '''simple docstring''' lowercase = abs(chargea * chargea ) if (force, chargea, chargea, distance).count(0 ) != 1: raise ValueError("""One and only one argument must be 0""" ) if distance < 0: raise ValueError("""Distance cannot be negative""" ) if force == 0: lowercase = COULOMBS_CONSTANT * charge_product / (distance**2) return {"force": force} elif chargea == 0: lowercase = abs(A__ ) * (distance**2) / (COULOMBS_CONSTANT * chargea) return {"charge1": chargea} elif chargea == 0: lowercase = abs(A__ ) * (distance**2) / (COULOMBS_CONSTANT * chargea) return {"charge2": chargea} elif distance == 0: lowercase = (COULOMBS_CONSTANT * charge_product / abs(A__ )) ** 0.5 return {"distance": distance} raise ValueError("""Exactly one argument must be 0""" ) if __name__ == "__main__": import doctest doctest.testmod()

# Copyright 2023 The HuggingFace Team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from typing import TYPE_CHECKING # rely on isort to merge the imports from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available lowerCAmelCase__ : Dict = { '''configuration_vivit''': ['''VIVIT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''VivitConfig'''], } try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowerCAmelCase__ : Union[str, Any] = ['''VivitImageProcessor'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowerCAmelCase__ : int = [ '''VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST''', '''VivitModel''', '''VivitPreTrainedModel''', '''VivitForVideoClassification''', ] if TYPE_CHECKING: from .configuration_vivit import VIVIT_PRETRAINED_CONFIG_ARCHIVE_MAP, VivitConfig try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .image_processing_vivit import VivitImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_vivit import ( VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST, VivitForVideoClassification, VivitModel, VivitPreTrainedModel, ) else: import sys lowerCAmelCase__ : int = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_speech_available, is_torch_available, ) lowerCAmelCase : Optional[Any] = { """configuration_trocr""": ["""TROCR_PRETRAINED_CONFIG_ARCHIVE_MAP""", """TrOCRConfig"""], """processing_trocr""": ["""TrOCRProcessor"""], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowerCAmelCase : Any = [ """TROCR_PRETRAINED_MODEL_ARCHIVE_LIST""", """TrOCRForCausalLM""", """TrOCRPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_trocr import TROCR_PRETRAINED_CONFIG_ARCHIVE_MAP, TrOCRConfig from .processing_trocr import TrOCRProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_trocr import TROCR_PRETRAINED_MODEL_ARCHIVE_LIST, TrOCRForCausalLM, TrOCRPreTrainedModel else: import sys lowerCAmelCase : Tuple = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

import unittest from queue import Empty from threading import Thread from transformers import AutoTokenizer, TextIteratorStreamer, TextStreamer, is_torch_available from transformers.testing_utils import CaptureStdout, require_torch, torch_device from ..test_modeling_common import ids_tensor if is_torch_available(): import torch from transformers import AutoModelForCausalLM @require_torch class __lowercase ( unittest.TestCase ): """simple docstring""" def _SCREAMING_SNAKE_CASE ( self : int): SCREAMING_SNAKE_CASE_: str = AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-gpt2") SCREAMING_SNAKE_CASE_: str = AutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2").to(lowerCAmelCase__) SCREAMING_SNAKE_CASE_: str = -1 SCREAMING_SNAKE_CASE_: Optional[int] = ids_tensor((1, 5) , vocab_size=model.config.vocab_size).to(lowerCAmelCase__) SCREAMING_SNAKE_CASE_: Any = model.generate(lowerCAmelCase__ , max_new_tokens=10 , do_sample=lowerCAmelCase__) SCREAMING_SNAKE_CASE_: List[str] = tokenizer.decode(greedy_ids[0]) with CaptureStdout() as cs: SCREAMING_SNAKE_CASE_: int = TextStreamer(lowerCAmelCase__) model.generate(lowerCAmelCase__ , max_new_tokens=10 , do_sample=lowerCAmelCase__ , streamer=lowerCAmelCase__) # The greedy text should be printed to stdout, except for the final "\n" in the streamer SCREAMING_SNAKE_CASE_: Union[str, Any] = cs.out[:-1] self.assertEqual(lowerCAmelCase__ , lowerCAmelCase__) def _SCREAMING_SNAKE_CASE ( self : int): SCREAMING_SNAKE_CASE_: List[Any] = AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-gpt2") SCREAMING_SNAKE_CASE_: int = AutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2").to(lowerCAmelCase__) SCREAMING_SNAKE_CASE_: List[Any] = -1 SCREAMING_SNAKE_CASE_: int = ids_tensor((1, 5) , vocab_size=model.config.vocab_size).to(lowerCAmelCase__) SCREAMING_SNAKE_CASE_: int = model.generate(lowerCAmelCase__ , max_new_tokens=10 , do_sample=lowerCAmelCase__) SCREAMING_SNAKE_CASE_: Tuple = tokenizer.decode(greedy_ids[0]) SCREAMING_SNAKE_CASE_: int = TextIteratorStreamer(lowerCAmelCase__) SCREAMING_SNAKE_CASE_: Optional[Any] = {"input_ids": input_ids, "max_new_tokens": 10, "do_sample": False, "streamer": streamer} SCREAMING_SNAKE_CASE_: Tuple = Thread(target=model.generate , kwargs=lowerCAmelCase__) thread.start() SCREAMING_SNAKE_CASE_: Optional[Any] = "" for new_text in streamer: streamer_text += new_text self.assertEqual(lowerCAmelCase__ , lowerCAmelCase__) def _SCREAMING_SNAKE_CASE ( self : Optional[int]): SCREAMING_SNAKE_CASE_: int = AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-gpt2") SCREAMING_SNAKE_CASE_: int = AutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2").to(lowerCAmelCase__) SCREAMING_SNAKE_CASE_: List[Any] = -1 SCREAMING_SNAKE_CASE_: Optional[Any] = ids_tensor((1, 5) , vocab_size=model.config.vocab_size).to(lowerCAmelCase__) SCREAMING_SNAKE_CASE_: Dict = model.generate(lowerCAmelCase__ , max_new_tokens=10 , do_sample=lowerCAmelCase__) SCREAMING_SNAKE_CASE_: Tuple = greedy_ids[:, input_ids.shape[1] :] SCREAMING_SNAKE_CASE_: Union[str, Any] = tokenizer.decode(new_greedy_ids[0]) with CaptureStdout() as cs: SCREAMING_SNAKE_CASE_: Dict = TextStreamer(lowerCAmelCase__ , skip_prompt=lowerCAmelCase__) model.generate(lowerCAmelCase__ , max_new_tokens=10 , do_sample=lowerCAmelCase__ , streamer=lowerCAmelCase__) # The greedy text should be printed to stdout, except for the final "\n" in the streamer SCREAMING_SNAKE_CASE_: Any = cs.out[:-1] self.assertEqual(lowerCAmelCase__ , lowerCAmelCase__) def _SCREAMING_SNAKE_CASE ( self : Tuple): # Tests that we can pass `decode_kwargs` to the streamer to control how the tokens are decoded. Must be tested # with actual models -- the dummy models' tokenizers are not aligned with their models, and # `skip_special_tokens=True` has no effect on them SCREAMING_SNAKE_CASE_: Tuple = AutoTokenizer.from_pretrained("distilgpt2") SCREAMING_SNAKE_CASE_: List[str] = AutoModelForCausalLM.from_pretrained("distilgpt2").to(lowerCAmelCase__) SCREAMING_SNAKE_CASE_: Optional[Any] = -1 SCREAMING_SNAKE_CASE_: List[str] = torch.ones((1, 5) , device=lowerCAmelCase__).long() * model.config.bos_token_id with CaptureStdout() as cs: SCREAMING_SNAKE_CASE_: Union[str, Any] = TextStreamer(lowerCAmelCase__ , skip_special_tokens=lowerCAmelCase__) model.generate(lowerCAmelCase__ , max_new_tokens=1 , do_sample=lowerCAmelCase__ , streamer=lowerCAmelCase__) # The prompt contains a special token, so the streamer should not print it. As such, the output text, when # re-tokenized, must only contain one token SCREAMING_SNAKE_CASE_: str = cs.out[:-1] # Remove the final "\n" SCREAMING_SNAKE_CASE_: Tuple = tokenizer(lowerCAmelCase__ , return_tensors="pt") self.assertEqual(streamer_text_tokenized.input_ids.shape , (1, 1)) def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): SCREAMING_SNAKE_CASE_: List[Any] = AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-gpt2") SCREAMING_SNAKE_CASE_: List[str] = AutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2").to(lowerCAmelCase__) SCREAMING_SNAKE_CASE_: Dict = -1 SCREAMING_SNAKE_CASE_: List[str] = ids_tensor((1, 5) , vocab_size=model.config.vocab_size).to(lowerCAmelCase__) SCREAMING_SNAKE_CASE_: Any = TextIteratorStreamer(lowerCAmelCase__ , timeout=0.001) SCREAMING_SNAKE_CASE_: Any = {"input_ids": input_ids, "max_new_tokens": 10, "do_sample": False, "streamer": streamer} SCREAMING_SNAKE_CASE_: Optional[Any] = Thread(target=model.generate , kwargs=lowerCAmelCase__) thread.start() # The streamer will timeout after 0.001 seconds, so an exception will be raised with self.assertRaises(lowerCAmelCase__): SCREAMING_SNAKE_CASE_: Tuple = "" for new_text in streamer: streamer_text += new_text

from dataclasses import asdict, dataclass from typing import Optional from ...configuration_utils import PretrainedConfig from ...utils import logging lowerCamelCase__ = logging.get_logger(__name__) # TODO Update this lowerCamelCase__ = { """facebook/esm-1b""": """https://huggingface.co/facebook/esm-1b/resolve/main/config.json""", # See all ESM models at https://huggingface.co/models?filter=esm } class SCREAMING_SNAKE_CASE ( lowerCamelCase__ ): __lowerCamelCase : Optional[int] ='esm' def __init__( self : str , __lowercase : Optional[Any]=None , __lowercase : Optional[Any]=None , __lowercase : Optional[int]=None , __lowercase : Union[str, Any]=768 , __lowercase : Optional[int]=12 , __lowercase : Dict=12 , __lowercase : Optional[Any]=3072 , __lowercase : Optional[Any]=0.1 , __lowercase : Dict=0.1 , __lowercase : int=1026 , __lowercase : int=0.02 , __lowercase : List[Any]=1E-12 , __lowercase : Dict="absolute" , __lowercase : Union[str, Any]=True , __lowercase : str=None , __lowercase : Any=False , __lowercase : Dict=False , __lowercase : int=None , __lowercase : str=None , **__lowercase : str , ): '''simple docstring''' super().__init__(pad_token_id=__lowercase , mask_token_id=__lowercase , **__lowercase ) __a = vocab_size __a = hidden_size __a = num_hidden_layers __a = num_attention_heads __a = intermediate_size __a = hidden_dropout_prob __a = attention_probs_dropout_prob __a = max_position_embeddings __a = initializer_range __a = layer_norm_eps __a = position_embedding_type __a = use_cache __a = emb_layer_norm_before __a = token_dropout __a = is_folding_model if is_folding_model: if esmfold_config is None: logger.info("""No esmfold_config supplied for folding model, using default values.""" ) __a = EsmFoldConfig() elif isinstance(__lowercase , __lowercase ): __a = EsmFoldConfig(**__lowercase ) __a = esmfold_config if vocab_list is None: logger.warning("""No vocab_list supplied for folding model, assuming the ESM-2 vocabulary!""" ) __a = get_default_vocab_list() else: __a = vocab_list else: __a = None __a = None if self.esmfold_config is not None and getattr(self.esmfold_config , """use_esm_attn_map""" , __lowercase ): raise ValueError("""The HuggingFace port of ESMFold does not support use_esm_attn_map at this time!""" ) def UpperCamelCase_ ( self : Tuple ): '''simple docstring''' __a = super().to_dict() if isinstance(self.esmfold_config , __lowercase ): __a = self.esmfold_config.to_dict() return output @dataclass class SCREAMING_SNAKE_CASE : __lowerCamelCase : str =None __lowerCamelCase : bool =True __lowerCamelCase : bool =False __lowerCamelCase : bool =False __lowerCamelCase : bool =False __lowerCamelCase : float =0 __lowerCamelCase : bool =True __lowerCamelCase : bool =False __lowerCamelCase : int =128 __lowerCamelCase : "TrunkConfig" =None def UpperCamelCase_ ( self : List[str] ): '''simple docstring''' if self.trunk is None: __a = TrunkConfig() elif isinstance(self.trunk , __lowercase ): __a = TrunkConfig(**self.trunk ) def UpperCamelCase_ ( self : int ): '''simple docstring''' __a = asdict(self ) __a = self.trunk.to_dict() return output @dataclass class SCREAMING_SNAKE_CASE : __lowerCamelCase : int =48 __lowerCamelCase : int =1_024 __lowerCamelCase : int =128 __lowerCamelCase : int =32 __lowerCamelCase : int =32 __lowerCamelCase : int =32 __lowerCamelCase : float =0 __lowerCamelCase : float =0 __lowerCamelCase : bool =False __lowerCamelCase : int =4 __lowerCamelCase : Optional[int] =128 __lowerCamelCase : "StructureModuleConfig" =None def UpperCamelCase_ ( self : Any ): '''simple docstring''' if self.structure_module is None: __a = StructureModuleConfig() elif isinstance(self.structure_module , __lowercase ): __a = StructureModuleConfig(**self.structure_module ) if self.max_recycles <= 0: raise ValueError(F"`max_recycles` should be positive, got {self.max_recycles}." ) if self.sequence_state_dim % self.sequence_state_dim != 0: raise ValueError( """`sequence_state_dim` should be a round multiple of `sequence_state_dim`, got""" F" {self.sequence_state_dim} and {self.sequence_state_dim}." ) if self.pairwise_state_dim % self.pairwise_state_dim != 0: raise ValueError( """`pairwise_state_dim` should be a round multiple of `pairwise_state_dim`, got""" F" {self.pairwise_state_dim} and {self.pairwise_state_dim}." ) __a = self.sequence_state_dim // self.sequence_head_width __a = self.pairwise_state_dim // self.pairwise_head_width if self.sequence_state_dim != sequence_num_heads * self.sequence_head_width: raise ValueError( """`sequence_state_dim` should be equal to `sequence_num_heads * sequence_head_width, got""" F" {self.sequence_state_dim} != {sequence_num_heads} * {self.sequence_head_width}." ) if self.pairwise_state_dim != pairwise_num_heads * self.pairwise_head_width: raise ValueError( """`pairwise_state_dim` should be equal to `pairwise_num_heads * pairwise_head_width, got""" F" {self.pairwise_state_dim} != {pairwise_num_heads} * {self.pairwise_head_width}." ) if self.pairwise_state_dim % 2 != 0: raise ValueError(F"`pairwise_state_dim` should be even, got {self.pairwise_state_dim}." ) if self.dropout >= 0.4: raise ValueError(F"`dropout` should not be greater than 0.4, got {self.dropout}." ) def UpperCamelCase_ ( self : Tuple ): '''simple docstring''' __a = asdict(self ) __a = self.structure_module.to_dict() return output @dataclass class SCREAMING_SNAKE_CASE : __lowerCamelCase : int =384 __lowerCamelCase : int =128 __lowerCamelCase : int =16 __lowerCamelCase : int =128 __lowerCamelCase : int =12 __lowerCamelCase : int =4 __lowerCamelCase : int =8 __lowerCamelCase : float =0.1 __lowerCamelCase : int =8 __lowerCamelCase : int =1 __lowerCamelCase : int =2 __lowerCamelCase : int =7 __lowerCamelCase : int =10 __lowerCamelCase : float =1e-8 __lowerCamelCase : float =1e5 def UpperCamelCase_ ( self : Dict ): '''simple docstring''' return asdict(self ) def lowerCAmelCase__ ( ): """simple docstring""" return ( "<cls>", "<pad>", "<eos>", "<unk>", "L", "A", "G", "V", "S", "E", "R", "T", "I", "D", "P", "K", "Q", "N", "F", "Y", "M", "H", "W", "C", "X", "B", "U", "Z", "O", ".", "-", "<null_1>", "<mask>", )

from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available, is_vision_available, ) lowerCamelCase__ = { """configuration_blip""": [ """BLIP_PRETRAINED_CONFIG_ARCHIVE_MAP""", """BlipConfig""", """BlipTextConfig""", """BlipVisionConfig""", ], """processing_blip""": ["""BlipProcessor"""], } try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowerCamelCase__ = ["""BlipImageProcessor"""] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowerCamelCase__ = [ """BLIP_PRETRAINED_MODEL_ARCHIVE_LIST""", """BlipModel""", """BlipPreTrainedModel""", """BlipForConditionalGeneration""", """BlipForQuestionAnswering""", """BlipVisionModel""", """BlipTextModel""", """BlipForImageTextRetrieval""", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowerCamelCase__ = [ """TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST""", """TFBlipModel""", """TFBlipPreTrainedModel""", """TFBlipForConditionalGeneration""", """TFBlipForQuestionAnswering""", """TFBlipVisionModel""", """TFBlipTextModel""", """TFBlipForImageTextRetrieval""", ] if TYPE_CHECKING: from .configuration_blip import BLIP_PRETRAINED_CONFIG_ARCHIVE_MAP, BlipConfig, BlipTextConfig, BlipVisionConfig from .processing_blip import BlipProcessor try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .image_processing_blip import BlipImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_blip import ( BLIP_PRETRAINED_MODEL_ARCHIVE_LIST, BlipForConditionalGeneration, BlipForImageTextRetrieval, BlipForQuestionAnswering, BlipModel, BlipPreTrainedModel, BlipTextModel, BlipVisionModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_blip import ( TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST, TFBlipForConditionalGeneration, TFBlipForImageTextRetrieval, TFBlipForQuestionAnswering, TFBlipModel, TFBlipPreTrainedModel, TFBlipTextModel, TFBlipVisionModel, ) else: import sys lowerCamelCase__ = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

'''simple docstring''' from __future__ import annotations import unittest from transformers import LEDConfig, 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 from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import tensorflow as tf from transformers import TFLEDForConditionalGeneration, TFLEDModel @require_tf class _UpperCAmelCase : a : List[str] =LEDConfig a : Optional[Any] ={} a : List[Any] ="""gelu""" def __init__( self,__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE=13,__SCREAMING_SNAKE_CASE=7,__SCREAMING_SNAKE_CASE=True,__SCREAMING_SNAKE_CASE=False,__SCREAMING_SNAKE_CASE=99,__SCREAMING_SNAKE_CASE=32,__SCREAMING_SNAKE_CASE=2,__SCREAMING_SNAKE_CASE=4,__SCREAMING_SNAKE_CASE=37,__SCREAMING_SNAKE_CASE=0.1,__SCREAMING_SNAKE_CASE=0.1,__SCREAMING_SNAKE_CASE=20,__SCREAMING_SNAKE_CASE=2,__SCREAMING_SNAKE_CASE=1,__SCREAMING_SNAKE_CASE=0,__SCREAMING_SNAKE_CASE=4,): '''simple docstring''' __lowerCAmelCase = parent __lowerCAmelCase = batch_size __lowerCAmelCase = seq_length __lowerCAmelCase = is_training __lowerCAmelCase = use_labels __lowerCAmelCase = vocab_size __lowerCAmelCase = hidden_size __lowerCAmelCase = num_hidden_layers __lowerCAmelCase = num_attention_heads __lowerCAmelCase = intermediate_size __lowerCAmelCase = hidden_dropout_prob __lowerCAmelCase = attention_probs_dropout_prob __lowerCAmelCase = max_position_embeddings __lowerCAmelCase = eos_token_id __lowerCAmelCase = pad_token_id __lowerCAmelCase = bos_token_id __lowerCAmelCase = attention_window # `ModelTesterMixin.test_attention_outputs` is expecting attention tensors to be of size # [num_attention_heads, encoder_seq_length, encoder_key_length], but TFLongformerSelfAttention # returns attention of shape [num_attention_heads, encoder_seq_length, self.attention_window + 1] # because its local attention only attends to `self.attention_window` and one before and one after __lowerCAmelCase = self.attention_window + 2 # because of padding `encoder_seq_length`, is different from `seq_length`. Relevant for # the `test_attention_outputs` and `test_hidden_states_output` tests __lowerCAmelCase = ( self.seq_length + (self.attention_window - self.seq_length % self.attention_window) % self.attention_window ) def lowerCamelCase__ ( self ): '''simple docstring''' __lowerCAmelCase = ids_tensor([self.batch_size, self.seq_length - 1],self.vocab_size ) __lowerCAmelCase = tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size ),1 ) __lowerCAmelCase = tf.concat([input_ids, eos_tensor],axis=1 ) __lowerCAmelCase = ids_tensor([self.batch_size, self.seq_length],self.vocab_size ) __lowerCAmelCase = 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,attention_window=self.attention_window,**self.config_updates,) __lowerCAmelCase = prepare_led_inputs_dict(__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE ) __lowerCAmelCase = tf.concat( [tf.zeros_like(__SCREAMING_SNAKE_CASE )[:, :-1], tf.ones_like(__SCREAMING_SNAKE_CASE )[:, -1:]],axis=-1,) __lowerCAmelCase = global_attention_mask return config, inputs_dict def lowerCamelCase__ ( self,__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE ): '''simple docstring''' __lowerCAmelCase = TFLEDModel(config=__SCREAMING_SNAKE_CASE ).get_decoder() __lowerCAmelCase = inputs_dict["""input_ids"""] __lowerCAmelCase = input_ids[:1, :] __lowerCAmelCase = inputs_dict["""attention_mask"""][:1, :] __lowerCAmelCase = 1 # first forward pass __lowerCAmelCase = model(__SCREAMING_SNAKE_CASE,attention_mask=__SCREAMING_SNAKE_CASE,use_cache=__SCREAMING_SNAKE_CASE ) __lowerCAmelCase , __lowerCAmelCase = outputs.to_tuple() # create hypothetical next token and extent to next_input_ids __lowerCAmelCase = ids_tensor((self.batch_size, 3),config.vocab_size ) __lowerCAmelCase = tf.cast(ids_tensor((self.batch_size, 3),2 ),tf.inta ) # append to next input_ids and __lowerCAmelCase = tf.concat([input_ids, next_tokens],axis=-1 ) __lowerCAmelCase = tf.concat([attention_mask, next_attn_mask],axis=-1 ) __lowerCAmelCase = model(__SCREAMING_SNAKE_CASE,attention_mask=__SCREAMING_SNAKE_CASE )[0] __lowerCAmelCase = 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 __lowerCAmelCase = int(ids_tensor((1,),output_from_past.shape[-1] ) ) __lowerCAmelCase = output_from_no_past[:, -3:, random_slice_idx] __lowerCAmelCase = 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 _lowerCAmelCase ( lowercase , lowercase , lowercase , lowercase=None , lowercase=None , lowercase=None , lowercase=None , ) -> int: if attention_mask is None: __lowerCAmelCase = tf.cast(tf.math.not_equal(lowercase , config.pad_token_id ) , tf.inta ) if decoder_attention_mask is None: __lowerCAmelCase = 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: __lowerCAmelCase = tf.ones((config.encoder_layers, config.encoder_attention_heads) ) if decoder_head_mask is None: __lowerCAmelCase = tf.ones((config.decoder_layers, config.decoder_attention_heads) ) return { "input_ids": input_ids, "attention_mask": attention_mask, "decoder_input_ids": decoder_input_ids, "decoder_attention_mask": decoder_attention_mask, "head_mask": head_mask, "decoder_head_mask": decoder_head_mask, } @require_tf class _UpperCAmelCase ( lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase ): a : List[str] =(TFLEDForConditionalGeneration, TFLEDModel) if is_tf_available() else () a : List[str] =(TFLEDForConditionalGeneration,) if is_tf_available() else () a : List[Any] =( { """conversational""": TFLEDForConditionalGeneration, """feature-extraction""": TFLEDModel, """summarization""": TFLEDForConditionalGeneration, """text2text-generation""": TFLEDForConditionalGeneration, """translation""": TFLEDForConditionalGeneration, } if is_tf_available() else {} ) a : str =True a : Any =False a : Dict =False a : Dict =False def lowerCamelCase__ ( self ): '''simple docstring''' __lowerCAmelCase = TFLEDModelTester(self ) __lowerCAmelCase = ConfigTester(self,config_class=__SCREAMING_SNAKE_CASE ) def lowerCamelCase__ ( self ): '''simple docstring''' self.config_tester.run_common_tests() def lowerCamelCase__ ( self ): '''simple docstring''' __lowerCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.check_decoder_model_past_large_inputs(*__SCREAMING_SNAKE_CASE ) def lowerCamelCase__ ( self ): '''simple docstring''' __lowerCAmelCase , __lowerCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() __lowerCAmelCase = tf.zeros_like(inputs_dict["""attention_mask"""] ) __lowerCAmelCase = 2 __lowerCAmelCase = tf.where( tf.range(self.model_tester.seq_length )[None, :] < num_global_attn_indices,1,inputs_dict["""global_attention_mask"""],) __lowerCAmelCase = True __lowerCAmelCase = self.model_tester.seq_length __lowerCAmelCase = self.model_tester.encoder_seq_length def check_decoder_attentions_output(__SCREAMING_SNAKE_CASE ): __lowerCAmelCase = outputs.decoder_attentions self.assertEqual(len(__SCREAMING_SNAKE_CASE ),self.model_tester.num_hidden_layers ) self.assertListEqual( list(decoder_attentions[0].shape[-3:] ),[self.model_tester.num_attention_heads, seq_length, seq_length],) def check_encoder_attentions_output(__SCREAMING_SNAKE_CASE ): __lowerCAmelCase = [t.numpy() for t in outputs.encoder_attentions] __lowerCAmelCase = [t.numpy() for t in outputs.encoder_global_attentions] self.assertEqual(len(__SCREAMING_SNAKE_CASE ),self.model_tester.num_hidden_layers ) self.assertEqual(len(__SCREAMING_SNAKE_CASE ),self.model_tester.num_hidden_layers ) self.assertListEqual( list(attentions[0].shape[-3:] ),[self.model_tester.num_attention_heads, seq_length, seq_length],) self.assertListEqual( list(global_attentions[0].shape[-3:] ),[self.model_tester.num_attention_heads, encoder_seq_length, num_global_attn_indices],) for model_class in self.all_model_classes: __lowerCAmelCase = True __lowerCAmelCase = False __lowerCAmelCase = False __lowerCAmelCase = model_class(__SCREAMING_SNAKE_CASE ) __lowerCAmelCase = model(self._prepare_for_class(__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE ) ) __lowerCAmelCase = len(__SCREAMING_SNAKE_CASE ) self.assertEqual(config.output_hidden_states,__SCREAMING_SNAKE_CASE ) check_encoder_attentions_output(__SCREAMING_SNAKE_CASE ) if self.is_encoder_decoder: __lowerCAmelCase = model_class(__SCREAMING_SNAKE_CASE ) __lowerCAmelCase = model(self._prepare_for_class(__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE ) ) self.assertEqual(config.output_hidden_states,__SCREAMING_SNAKE_CASE ) check_decoder_attentions_output(__SCREAMING_SNAKE_CASE ) # Check that output attentions can also be changed via the config del inputs_dict["output_attentions"] __lowerCAmelCase = True __lowerCAmelCase = model_class(__SCREAMING_SNAKE_CASE ) __lowerCAmelCase = model(self._prepare_for_class(__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE ) ) self.assertEqual(config.output_hidden_states,__SCREAMING_SNAKE_CASE ) check_encoder_attentions_output(__SCREAMING_SNAKE_CASE ) # Check attention is always last and order is fine __lowerCAmelCase = True __lowerCAmelCase = True __lowerCAmelCase = model_class(__SCREAMING_SNAKE_CASE ) __lowerCAmelCase = model(self._prepare_for_class(__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE ) ) self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1),len(__SCREAMING_SNAKE_CASE ) ) self.assertEqual(model.config.output_hidden_states,__SCREAMING_SNAKE_CASE ) check_encoder_attentions_output(__SCREAMING_SNAKE_CASE ) @unittest.skip("""LED keeps using potentially symbolic tensors in conditionals and breaks tracing.""" ) def lowerCamelCase__ ( self ): '''simple docstring''' pass def lowerCamelCase__ ( self ): '''simple docstring''' pass def _lowerCAmelCase ( lowercase ) -> Optional[int]: return tf.constant(lowercase , dtype=tf.intaa ) _a : Tuple = 1E-4 @slow @require_tf class _UpperCAmelCase ( unittest.TestCase ): def lowerCamelCase__ ( self ): '''simple docstring''' __lowerCAmelCase = TFLEDForConditionalGeneration.from_pretrained("""allenai/led-base-16384""" ).led # change to intended input here __lowerCAmelCase = _long_tensor([5_12 * [0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69]] ) __lowerCAmelCase = _long_tensor([1_28 * [0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69]] ) __lowerCAmelCase = prepare_led_inputs_dict(model.config,__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE ) __lowerCAmelCase = model(**__SCREAMING_SNAKE_CASE )[0] __lowerCAmelCase = (1, 10_24, 7_68) self.assertEqual(output.shape,__SCREAMING_SNAKE_CASE ) # change to expected output here __lowerCAmelCase = tf.convert_to_tensor( [[2.3050, 2.8279, 0.6531], [-1.8457, -0.1455, -3.5661], [-1.0186, 0.4586, -2.2043]],) tf.debugging.assert_near(output[:, :3, :3],__SCREAMING_SNAKE_CASE,atol=1e-3 ) def lowerCamelCase__ ( self ): '''simple docstring''' __lowerCAmelCase = TFLEDForConditionalGeneration.from_pretrained("""allenai/led-base-16384""" ) # change to intended input here __lowerCAmelCase = _long_tensor([5_12 * [0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69]] ) __lowerCAmelCase = _long_tensor([1_28 * [0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69]] ) __lowerCAmelCase = prepare_led_inputs_dict(model.config,__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE ) __lowerCAmelCase = model(**__SCREAMING_SNAKE_CASE )[0] __lowerCAmelCase = (1, 10_24, model.config.vocab_size) self.assertEqual(output.shape,__SCREAMING_SNAKE_CASE ) # change to expected output here __lowerCAmelCase = tf.convert_to_tensor( [[33.6507, 6.4572, 16.8089], [5.8739, -2.4238, 11.2902], [-3.2139, -4.3149, 4.2783]],) tf.debugging.assert_near(output[:, :3, :3],__SCREAMING_SNAKE_CASE,atol=1e-3,rtol=1e-3 )

'''simple docstring''' import gc import random import unittest import numpy as np import torch from PIL import Image from diffusers import ( DDIMScheduler, KandinskyVaaImgaImgPipeline, KandinskyVaaPriorPipeline, UNetaDConditionModel, VQModel, ) 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 from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference enable_full_determinism() class _UpperCAmelCase ( lowerCAmelCase_ , unittest.TestCase ): a : Optional[int] =KandinskyVaaImgaImgPipeline a : List[Any] =["""image_embeds""", """negative_image_embeds""", """image"""] a : Union[str, Any] =[ """image_embeds""", """negative_image_embeds""", """image""", ] a : Optional[int] =[ """generator""", """height""", """width""", """strength""", """guidance_scale""", """num_inference_steps""", """return_dict""", """guidance_scale""", """num_images_per_prompt""", """output_type""", """return_dict""", ] a : Optional[Any] =False @property def lowerCamelCase__ ( self ): '''simple docstring''' return 32 @property def lowerCamelCase__ ( self ): '''simple docstring''' return 32 @property def lowerCamelCase__ ( self ): '''simple docstring''' return self.time_input_dim @property def lowerCamelCase__ ( self ): '''simple docstring''' return self.time_input_dim * 4 @property def lowerCamelCase__ ( self ): '''simple docstring''' return 1_00 @property def lowerCamelCase__ ( self ): '''simple docstring''' torch.manual_seed(0 ) __lowerCAmelCase = { """in_channels""": 4, # Out channels is double in channels because predicts mean and variance """out_channels""": 8, """addition_embed_type""": """image""", """down_block_types""": ("""ResnetDownsampleBlock2D""", """SimpleCrossAttnDownBlock2D"""), """up_block_types""": ("""SimpleCrossAttnUpBlock2D""", """ResnetUpsampleBlock2D"""), """mid_block_type""": """UNetMidBlock2DSimpleCrossAttn""", """block_out_channels""": (self.block_out_channels_a, self.block_out_channels_a * 2), """layers_per_block""": 1, """encoder_hid_dim""": self.text_embedder_hidden_size, """encoder_hid_dim_type""": """image_proj""", """cross_attention_dim""": self.cross_attention_dim, """attention_head_dim""": 4, """resnet_time_scale_shift""": """scale_shift""", """class_embed_type""": None, } __lowerCAmelCase = UNetaDConditionModel(**__SCREAMING_SNAKE_CASE ) return model @property def lowerCamelCase__ ( self ): '''simple docstring''' return { "block_out_channels": [32, 64], "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"], "in_channels": 3, "latent_channels": 4, "layers_per_block": 1, "norm_num_groups": 8, "norm_type": "spatial", "num_vq_embeddings": 12, "out_channels": 3, "up_block_types": [ "AttnUpDecoderBlock2D", "UpDecoderBlock2D", ], "vq_embed_dim": 4, } @property def lowerCamelCase__ ( self ): '''simple docstring''' torch.manual_seed(0 ) __lowerCAmelCase = VQModel(**self.dummy_movq_kwargs ) return model def lowerCamelCase__ ( self ): '''simple docstring''' __lowerCAmelCase = self.dummy_unet __lowerCAmelCase = self.dummy_movq __lowerCAmelCase = { """num_train_timesteps""": 10_00, """beta_schedule""": """linear""", """beta_start""": 0.0_0085, """beta_end""": 0.012, """clip_sample""": False, """set_alpha_to_one""": False, """steps_offset""": 0, """prediction_type""": """epsilon""", """thresholding""": False, } __lowerCAmelCase = DDIMScheduler(**__SCREAMING_SNAKE_CASE ) __lowerCAmelCase = { """unet""": unet, """scheduler""": scheduler, """movq""": movq, } return components def lowerCamelCase__ ( self,__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE=0 ): '''simple docstring''' __lowerCAmelCase = floats_tensor((1, self.text_embedder_hidden_size),rng=random.Random(__SCREAMING_SNAKE_CASE ) ).to(__SCREAMING_SNAKE_CASE ) __lowerCAmelCase = floats_tensor((1, self.text_embedder_hidden_size),rng=random.Random(seed + 1 ) ).to( __SCREAMING_SNAKE_CASE ) # create init_image __lowerCAmelCase = floats_tensor((1, 3, 64, 64),rng=random.Random(__SCREAMING_SNAKE_CASE ) ).to(__SCREAMING_SNAKE_CASE ) __lowerCAmelCase = image.cpu().permute(0,2,3,1 )[0] __lowerCAmelCase = Image.fromarray(np.uinta(__SCREAMING_SNAKE_CASE ) ).convert("""RGB""" ).resize((2_56, 2_56) ) if str(__SCREAMING_SNAKE_CASE ).startswith("""mps""" ): __lowerCAmelCase = torch.manual_seed(__SCREAMING_SNAKE_CASE ) else: __lowerCAmelCase = torch.Generator(device=__SCREAMING_SNAKE_CASE ).manual_seed(__SCREAMING_SNAKE_CASE ) __lowerCAmelCase = { """image""": init_image, """image_embeds""": image_embeds, """negative_image_embeds""": negative_image_embeds, """generator""": generator, """height""": 64, """width""": 64, """num_inference_steps""": 10, """guidance_scale""": 7.0, """strength""": 0.2, """output_type""": """np""", } return inputs def lowerCamelCase__ ( self ): '''simple docstring''' __lowerCAmelCase = """cpu""" __lowerCAmelCase = self.get_dummy_components() __lowerCAmelCase = self.pipeline_class(**__SCREAMING_SNAKE_CASE ) __lowerCAmelCase = pipe.to(__SCREAMING_SNAKE_CASE ) pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE ) __lowerCAmelCase = pipe(**self.get_dummy_inputs(__SCREAMING_SNAKE_CASE ) ) __lowerCAmelCase = output.images __lowerCAmelCase = pipe( **self.get_dummy_inputs(__SCREAMING_SNAKE_CASE ),return_dict=__SCREAMING_SNAKE_CASE,)[0] __lowerCAmelCase = image[0, -3:, -3:, -1] __lowerCAmelCase = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) __lowerCAmelCase = np.array( [0.619_9778, 0.6398_4406, 0.4614_5785, 0.6294_4984, 0.562_2215, 0.4730_6132, 0.4744_1456, 0.460_7606, 0.4871_9263] ) assert ( np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 ), f' expected_slice {expected_slice}, but got {image_slice.flatten()}' assert ( np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1e-2 ), f' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}' @slow @require_torch_gpu class _UpperCAmelCase ( unittest.TestCase ): def lowerCamelCase__ ( self ): '''simple docstring''' super().tearDown() gc.collect() torch.cuda.empty_cache() def lowerCamelCase__ ( self ): '''simple docstring''' __lowerCAmelCase = load_numpy( """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main""" """/kandinskyv22/kandinskyv22_img2img_frog.npy""" ) __lowerCAmelCase = load_image( """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main""" """/kandinsky/cat.png""" ) __lowerCAmelCase = """A red cartoon frog, 4k""" __lowerCAmelCase = KandinskyVaaPriorPipeline.from_pretrained( """kandinsky-community/kandinsky-2-2-prior""",torch_dtype=torch.floataa ) pipe_prior.to(__SCREAMING_SNAKE_CASE ) __lowerCAmelCase = KandinskyVaaImgaImgPipeline.from_pretrained( """kandinsky-community/kandinsky-2-2-decoder""",torch_dtype=torch.floataa ) __lowerCAmelCase = pipeline.to(__SCREAMING_SNAKE_CASE ) pipeline.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE ) __lowerCAmelCase = torch.Generator(device="""cpu""" ).manual_seed(0 ) __lowerCAmelCase , __lowerCAmelCase = pipe_prior( __SCREAMING_SNAKE_CASE,generator=__SCREAMING_SNAKE_CASE,num_inference_steps=5,negative_prompt="""""",).to_tuple() __lowerCAmelCase = pipeline( image=__SCREAMING_SNAKE_CASE,image_embeds=__SCREAMING_SNAKE_CASE,negative_image_embeds=__SCREAMING_SNAKE_CASE,generator=__SCREAMING_SNAKE_CASE,num_inference_steps=1_00,height=7_68,width=7_68,strength=0.2,output_type="""np""",) __lowerCAmelCase = output.images[0] assert image.shape == (7_68, 7_68, 3) assert_mean_pixel_difference(__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE )

import warnings from functools import wraps from typing import Callable def __lowercase ( _UpperCamelCase ) ->Callable: """simple docstring""" @wraps(__snake_case ) def _inner_fn(*_UpperCamelCase, **_UpperCamelCase ): warnings.warn( (f"""\'{fn.__name__}\' is experimental and might be subject to breaking changes in the future."""), __snake_case, ) return fn(*__snake_case, **__snake_case ) return _inner_fn

'''simple docstring''' from sympy import diff, lambdify, symbols from sympy.functions import * # noqa: F403 def _lowerCAmelCase ( __snake_case : str , __snake_case : complex , __snake_case : str = "x" , __snake_case : float = 10**-10 , __snake_case : int = 1 , ) -> complex: __A : int = symbols(__snake_case ) __A : Tuple = lambdify(__snake_case , __snake_case ) __A : Any = lambdify(__snake_case , diff(__snake_case , __snake_case ) ) __A : str = starting_point while True: if diff_function(__snake_case ) != 0: __A : Optional[Any] = prev_guess - multiplicity * func(__snake_case ) / diff_function( __snake_case ) else: raise ZeroDivisionError('Could not find root' ) from None # Precision is checked by comparing the difference of consecutive guesses if abs(next_guess - prev_guess ) < precision: return next_guess __A : Dict = next_guess # Let's Execute if __name__ == "__main__": # Find root of trigonometric function # Find value of pi print(f"""The root of sin(x) = 0 is {newton_raphson("sin(x)", 2)}""") # Find root of polynomial # Find fourth Root of 5 print(f"""The root of x**4 - 5 = 0 is {newton_raphson("x**4 -5", 0.4 +5j)}""") # Find value of e print( '''The root of log(y) - 1 = 0 is ''', f"""{newton_raphson("log(y) - 1", 2, variable="y")}""", ) # Exponential Roots print( '''The root of exp(x) - 1 = 0 is''', f"""{newton_raphson("exp(x) - 1", 10, precision=0.005)}""", ) # Find root of cos(x) print(f"""The root of cos(x) = 0 is {newton_raphson("cos(x)", 0)}""")

'''simple docstring''' from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available lowercase__ = { "configuration_timesformer": ["TIMESFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP", "TimesformerConfig"], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase__ = [ "TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST", "TimesformerModel", "TimesformerForVideoClassification", "TimesformerPreTrainedModel", ] if TYPE_CHECKING: from .configuration_timesformer import TIMESFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, TimesformerConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_timesformer import ( TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, TimesformerForVideoClassification, TimesformerModel, TimesformerPreTrainedModel, ) else: import sys lowercase__ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)

'''simple docstring''' import requests lowercase__ = "" # <-- Put your OpenWeatherMap appid here! lowercase__ = "https://api.openweathermap.org/data/2.5/" def _UpperCamelCase ( SCREAMING_SNAKE_CASE__ = "Chicago" , SCREAMING_SNAKE_CASE__ = APPID ) -> dict: '''simple docstring''' return requests.get(URL_BASE + '''weather''' , params=locals() ).json() def _UpperCamelCase ( SCREAMING_SNAKE_CASE__ = "Kolkata, India" , SCREAMING_SNAKE_CASE__ = APPID ) -> dict: '''simple docstring''' return requests.get(URL_BASE + '''forecast''' , params=locals() ).json() def _UpperCamelCase ( SCREAMING_SNAKE_CASE__ = 55.68 , SCREAMING_SNAKE_CASE__ = 12.57 , SCREAMING_SNAKE_CASE__ = APPID ) -> dict: '''simple docstring''' return requests.get(URL_BASE + '''onecall''' , params=locals() ).json() if __name__ == "__main__": from pprint import pprint while True: lowercase__ = input("Enter a location:").strip() if location: pprint(current_weather(location)) else: break

from argparse import ArgumentParser from .env import EnvironmentCommand def _a ( ) -> List[str]: """simple docstring""" lowerCamelCase__ : Tuple = ArgumentParser('''Diffusers CLI tool''' , usage='''diffusers-cli <command> [<args>]''' ) lowerCamelCase__ : Optional[Any] = parser.add_subparsers(help='''diffusers-cli command helpers''' ) # Register commands EnvironmentCommand.register_subcommand(UpperCAmelCase ) # Let's go lowerCamelCase__ : Any = parser.parse_args() if not hasattr(UpperCAmelCase , '''func''' ): parser.print_help() exit(1 ) # Run lowerCamelCase__ : Optional[int] = args.func(UpperCAmelCase ) service.run() if __name__ == "__main__": main()

import argparse import json import requests import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import ConvNextConfig, SegformerImageProcessor, UperNetConfig, UperNetForSemanticSegmentation def _a ( UpperCAmelCase ) -> List[str]: """simple docstring""" lowerCamelCase__ : Union[str, Any] = 384 if "tiny" in model_name: lowerCamelCase__ : Optional[int] = [3, 3, 9, 3] lowerCamelCase__ : Tuple = [96, 192, 384, 768] if "small" in model_name: lowerCamelCase__ : Dict = [3, 3, 27, 3] lowerCamelCase__ : Any = [96, 192, 384, 768] if "base" in model_name: lowerCamelCase__ : Optional[int] = [3, 3, 27, 3] lowerCamelCase__ : Optional[Any] = [128, 256, 512, 1024] lowerCamelCase__ : List[Any] = 512 if "large" in model_name: lowerCamelCase__ : List[str] = [3, 3, 27, 3] lowerCamelCase__ : int = [192, 384, 768, 1536] lowerCamelCase__ : str = 768 if "xlarge" in model_name: lowerCamelCase__ : Any = [3, 3, 27, 3] lowerCamelCase__ : str = [256, 512, 1024, 2048] lowerCamelCase__ : Optional[Any] = 1024 # set label information lowerCamelCase__ : Optional[int] = 150 lowerCamelCase__ : Any = '''huggingface/label-files''' lowerCamelCase__ : Any = '''ade20k-id2label.json''' lowerCamelCase__ : str = json.load(open(hf_hub_download(UpperCAmelCase , UpperCAmelCase , repo_type='''dataset''' ) , '''r''' ) ) lowerCamelCase__ : Optional[Any] = {int(UpperCAmelCase ): v for k, v in idalabel.items()} lowerCamelCase__ : List[Any] = {v: k for k, v in idalabel.items()} lowerCamelCase__ : Any = ConvNextConfig( depths=UpperCAmelCase , hidden_sizes=UpperCAmelCase , out_features=['''stage1''', '''stage2''', '''stage3''', '''stage4'''] ) lowerCamelCase__ : Dict = UperNetConfig( backbone_config=UpperCAmelCase , auxiliary_in_channels=UpperCAmelCase , num_labels=UpperCAmelCase , idalabel=UpperCAmelCase , labelaid=UpperCAmelCase , ) return config def _a ( UpperCAmelCase ) -> int: """simple docstring""" lowerCamelCase__ : Dict = [] # fmt: off # stem rename_keys.append(('''backbone.downsample_layers.0.0.weight''', '''backbone.embeddings.patch_embeddings.weight''') ) rename_keys.append(('''backbone.downsample_layers.0.0.bias''', '''backbone.embeddings.patch_embeddings.bias''') ) rename_keys.append(('''backbone.downsample_layers.0.1.weight''', '''backbone.embeddings.layernorm.weight''') ) rename_keys.append(('''backbone.downsample_layers.0.1.bias''', '''backbone.embeddings.layernorm.bias''') ) # stages for i in range(len(config.backbone_config.depths ) ): for j in range(config.backbone_config.depths[i] ): rename_keys.append((f"backbone.stages.{i}.{j}.gamma", f"backbone.encoder.stages.{i}.layers.{j}.layer_scale_parameter") ) rename_keys.append((f"backbone.stages.{i}.{j}.depthwise_conv.weight", f"backbone.encoder.stages.{i}.layers.{j}.dwconv.weight") ) rename_keys.append((f"backbone.stages.{i}.{j}.depthwise_conv.bias", f"backbone.encoder.stages.{i}.layers.{j}.dwconv.bias") ) rename_keys.append((f"backbone.stages.{i}.{j}.norm.weight", f"backbone.encoder.stages.{i}.layers.{j}.layernorm.weight") ) rename_keys.append((f"backbone.stages.{i}.{j}.norm.bias", f"backbone.encoder.stages.{i}.layers.{j}.layernorm.bias") ) rename_keys.append((f"backbone.stages.{i}.{j}.pointwise_conv1.weight", f"backbone.encoder.stages.{i}.layers.{j}.pwconv1.weight") ) rename_keys.append((f"backbone.stages.{i}.{j}.pointwise_conv1.bias", f"backbone.encoder.stages.{i}.layers.{j}.pwconv1.bias") ) rename_keys.append((f"backbone.stages.{i}.{j}.pointwise_conv2.weight", f"backbone.encoder.stages.{i}.layers.{j}.pwconv2.weight") ) rename_keys.append((f"backbone.stages.{i}.{j}.pointwise_conv2.bias", f"backbone.encoder.stages.{i}.layers.{j}.pwconv2.bias") ) if i > 0: rename_keys.append((f"backbone.downsample_layers.{i}.0.weight", f"backbone.encoder.stages.{i}.downsampling_layer.0.weight") ) rename_keys.append((f"backbone.downsample_layers.{i}.0.bias", f"backbone.encoder.stages.{i}.downsampling_layer.0.bias") ) rename_keys.append((f"backbone.downsample_layers.{i}.1.weight", f"backbone.encoder.stages.{i}.downsampling_layer.1.weight") ) rename_keys.append((f"backbone.downsample_layers.{i}.1.bias", f"backbone.encoder.stages.{i}.downsampling_layer.1.bias") ) rename_keys.append((f"backbone.norm{i}.weight", f"backbone.hidden_states_norms.stage{i+1}.weight") ) rename_keys.append((f"backbone.norm{i}.bias", f"backbone.hidden_states_norms.stage{i+1}.bias") ) # decode head rename_keys.extend( [ ('''decode_head.conv_seg.weight''', '''decode_head.classifier.weight'''), ('''decode_head.conv_seg.bias''', '''decode_head.classifier.bias'''), ('''auxiliary_head.conv_seg.weight''', '''auxiliary_head.classifier.weight'''), ('''auxiliary_head.conv_seg.bias''', '''auxiliary_head.classifier.bias'''), ] ) # fmt: on return rename_keys def _a ( UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) -> Optional[Any]: """simple docstring""" lowerCamelCase__ : str = dct.pop(UpperCAmelCase ) lowerCamelCase__ : List[Any] = val def _a ( UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) -> Dict: """simple docstring""" lowerCamelCase__ : str = { '''upernet-convnext-tiny''': '''https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_tiny_fp16_512x512_160k_ade20k/upernet_convnext_tiny_fp16_512x512_160k_ade20k_20220227_124553-cad485de.pth''', '''upernet-convnext-small''': '''https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_small_fp16_512x512_160k_ade20k/upernet_convnext_small_fp16_512x512_160k_ade20k_20220227_131208-1b1e394f.pth''', '''upernet-convnext-base''': '''https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_base_fp16_512x512_160k_ade20k/upernet_convnext_base_fp16_512x512_160k_ade20k_20220227_181227-02a24fc6.pth''', '''upernet-convnext-large''': '''https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_large_fp16_640x640_160k_ade20k/upernet_convnext_large_fp16_640x640_160k_ade20k_20220226_040532-e57aa54d.pth''', '''upernet-convnext-xlarge''': '''https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_xlarge_fp16_640x640_160k_ade20k/upernet_convnext_xlarge_fp16_640x640_160k_ade20k_20220226_080344-95fc38c2.pth''', } lowerCamelCase__ : Union[str, Any] = model_name_to_url[model_name] lowerCamelCase__ : int = torch.hub.load_state_dict_from_url(UpperCAmelCase , map_location='''cpu''' )['''state_dict'''] lowerCamelCase__ : List[str] = get_upernet_config(UpperCAmelCase ) lowerCamelCase__ : Tuple = UperNetForSemanticSegmentation(UpperCAmelCase ) model.eval() # replace "bn" => "batch_norm" for key in state_dict.copy().keys(): lowerCamelCase__ : Optional[int] = state_dict.pop(UpperCAmelCase ) if "bn" in key: lowerCamelCase__ : str = key.replace('''bn''' , '''batch_norm''' ) lowerCamelCase__ : List[Any] = val # rename keys lowerCamelCase__ : List[str] = create_rename_keys(UpperCAmelCase ) for src, dest in rename_keys: rename_key(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) model.load_state_dict(UpperCAmelCase ) # verify on image lowerCamelCase__ : Any = '''https://huggingface.co/datasets/hf-internal-testing/fixtures_ade20k/resolve/main/ADE_val_00000001.jpg''' lowerCamelCase__ : List[str] = Image.open(requests.get(UpperCAmelCase , stream=UpperCAmelCase ).raw ).convert('''RGB''' ) lowerCamelCase__ : Optional[int] = SegformerImageProcessor() lowerCamelCase__ : Any = processor(UpperCAmelCase , return_tensors='''pt''' ).pixel_values with torch.no_grad(): lowerCamelCase__ : List[Any] = model(UpperCAmelCase ) if model_name == "upernet-convnext-tiny": lowerCamelCase__ : Any = torch.tensor( [[-8.81_10, -8.81_10, -8.65_21], [-8.81_10, -8.81_10, -8.65_21], [-8.77_46, -8.77_46, -8.61_30]] ) elif model_name == "upernet-convnext-small": lowerCamelCase__ : List[str] = torch.tensor( [[-8.82_36, -8.82_36, -8.67_71], [-8.82_36, -8.82_36, -8.67_71], [-8.76_38, -8.76_38, -8.62_40]] ) elif model_name == "upernet-convnext-base": lowerCamelCase__ : str = torch.tensor( [[-8.85_58, -8.85_58, -8.69_05], [-8.85_58, -8.85_58, -8.69_05], [-8.76_69, -8.76_69, -8.60_21]] ) elif model_name == "upernet-convnext-large": lowerCamelCase__ : Optional[int] = torch.tensor( [[-8.66_60, -8.66_60, -8.62_10], [-8.66_60, -8.66_60, -8.62_10], [-8.63_10, -8.63_10, -8.59_64]] ) elif model_name == "upernet-convnext-xlarge": lowerCamelCase__ : Tuple = torch.tensor( [[-8.49_80, -8.49_80, -8.39_77], [-8.49_80, -8.49_80, -8.39_77], [-8.43_79, -8.43_79, -8.34_12]] ) print('''Logits:''' , outputs.logits[0, 0, :3, :3] ) assert torch.allclose(outputs.logits[0, 0, :3, :3] , UpperCAmelCase , atol=1E-4 ) print('''Looks ok!''' ) if pytorch_dump_folder_path is not None: print(f"Saving model {model_name} to {pytorch_dump_folder_path}" ) model.save_pretrained(UpperCAmelCase ) print(f"Saving processor to {pytorch_dump_folder_path}" ) processor.save_pretrained(UpperCAmelCase ) if push_to_hub: print(f"Pushing model and processor for {model_name} to hub" ) model.push_to_hub(f"openmmlab/{model_name}" ) processor.push_to_hub(f"openmmlab/{model_name}" ) if __name__ == "__main__": _A : Union[str, Any] = argparse.ArgumentParser() # Required parameters parser.add_argument( '--model_name', default='upernet-convnext-tiny', type=str, choices=[F'''upernet-convnext-{size}''' for size in ['tiny', 'small', 'base', 'large', 'xlarge']], help='Name of the ConvNext UperNet model you\'d like to convert.', ) parser.add_argument( '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.' ) parser.add_argument( '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.' ) _A : Tuple = parser.parse_args() convert_upernet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)

'''simple docstring''' import random import unittest from torch.utils.data import BatchSampler, DataLoader, IterableDataset from accelerate import Accelerator from accelerate.data_loader import ( BatchSamplerShard, DataLoaderDispatcher, DataLoaderShard, IterableDatasetShard, SkipBatchSampler, SkipDataLoader, skip_first_batches, ) class UpperCamelCase_ ( __magic_name__ ): def __init__( self , A=0.0_1 , A=1000 ) -> List[str]: UpperCAmelCase : List[Any] = p_stop UpperCAmelCase : Optional[int] = max_length def __iter__( self ) -> Union[str, Any]: UpperCAmelCase : Dict = 0 UpperCAmelCase : Union[str, Any] = False while not stop and count < self.max_length: yield count count += 1 UpperCAmelCase : Any = random.random() < self.p_stop class UpperCamelCase_ ( unittest.TestCase ): def _lowercase( self , A , A , A=False , A=True ) -> Union[str, Any]: UpperCAmelCase : List[str] = [ BatchSamplerShard(A , 2 , A , split_batches=A , even_batches=A ) for i in range(2 ) ] UpperCAmelCase : List[str] = [list(A ) for batch_sampler_shard in batch_sampler_shards] if not split_batches: self.assertListEqual([len(A ) for shard in batch_sampler_shards] , [len(A ) for e in expected] ) self.assertListEqual(A , A ) def _lowercase( self ) -> Union[str, Any]: # Check the shards when the dataset is a round multiple of total batch size. UpperCAmelCase : int = BatchSampler(range(24 ) , batch_size=3 , drop_last=A ) UpperCAmelCase : Any = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]], [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21, 22, 23]], ] self.check_batch_sampler_shards(A , A ) UpperCAmelCase : Union[str, Any] = BatchSampler(range(24 ) , batch_size=3 , drop_last=A ) # Expected shouldn't change self.check_batch_sampler_shards(A , A ) # Check the shards when the dataset is a round multiple of batch size but not total batch size. UpperCAmelCase : Tuple = BatchSampler(range(21 ) , batch_size=3 , drop_last=A ) UpperCAmelCase : Optional[int] = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]], [[3, 4, 5], [9, 10, 11], [15, 16, 17], [0, 1, 2]], ] self.check_batch_sampler_shards(A , A ) UpperCAmelCase : Optional[int] = BatchSampler(range(21 ) , batch_size=3 , drop_last=A ) UpperCAmelCase : Optional[int] = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14]], [[3, 4, 5], [9, 10, 11], [15, 16, 17]], ] self.check_batch_sampler_shards(A , A ) # Check the shards when the dataset is not a round multiple of batch size but has a multiple of # num_processes batch. UpperCAmelCase : Tuple = BatchSampler(range(22 ) , batch_size=3 , drop_last=A ) UpperCAmelCase : Tuple = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]], [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21, 0, 1]], ] self.check_batch_sampler_shards(A , A ) UpperCAmelCase : int = BatchSampler(range(22 ) , batch_size=3 , drop_last=A ) UpperCAmelCase : List[Any] = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14]], [[3, 4, 5], [9, 10, 11], [15, 16, 17]], ] self.check_batch_sampler_shards(A , A ) # Check the shards when the dataset is not a round multiple of batch size but and has not a multiple of # num_processes batch. UpperCAmelCase : Union[str, Any] = BatchSampler(range(20 ) , batch_size=3 , drop_last=A ) UpperCAmelCase : Optional[int] = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 0]], [[3, 4, 5], [9, 10, 11], [15, 16, 17], [1, 2, 3]], ] self.check_batch_sampler_shards(A , A ) UpperCAmelCase : Optional[Any] = BatchSampler(range(20 ) , batch_size=3 , drop_last=A ) UpperCAmelCase : int = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14]], [[3, 4, 5], [9, 10, 11], [15, 16, 17]], ] self.check_batch_sampler_shards(A , A ) # Check the shards when the dataset is very small. UpperCAmelCase : Any = BatchSampler(range(2 ) , batch_size=3 , drop_last=A ) UpperCAmelCase : Union[str, Any] = [[[0, 1, 0]], [[1, 0, 1]]] self.check_batch_sampler_shards(A , A ) UpperCAmelCase : Dict = BatchSampler(range(2 ) , batch_size=3 , drop_last=A ) UpperCAmelCase : List[Any] = [[], []] self.check_batch_sampler_shards(A , A ) def _lowercase( self ) -> Tuple: # Check the shards when the dataset is a round multiple of batch size. UpperCAmelCase : Any = BatchSampler(range(24 ) , batch_size=4 , drop_last=A ) UpperCAmelCase : List[str] = [ [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]], [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [22, 23]], ] self.check_batch_sampler_shards(A , A , split_batches=A ) UpperCAmelCase : List[Any] = BatchSampler(range(24 ) , batch_size=4 , drop_last=A ) # Expected shouldn't change self.check_batch_sampler_shards(A , A , split_batches=A ) # Check the shards when the dataset is not a round multiple of batch size. UpperCAmelCase : Optional[Any] = BatchSampler(range(22 ) , batch_size=4 , drop_last=A ) UpperCAmelCase : List[str] = [ [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]], [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [0, 1]], ] self.check_batch_sampler_shards(A , A , split_batches=A ) UpperCAmelCase : Union[str, Any] = BatchSampler(range(22 ) , batch_size=4 , drop_last=A ) UpperCAmelCase : Union[str, Any] = [ [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]], [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]], ] self.check_batch_sampler_shards(A , A , split_batches=A ) # Check the shards when the dataset is not a round multiple of batch size or num_processes. UpperCAmelCase : Any = BatchSampler(range(21 ) , batch_size=4 , drop_last=A ) UpperCAmelCase : Any = [ [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 0]], [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [1, 2]], ] self.check_batch_sampler_shards(A , A , split_batches=A ) UpperCAmelCase : int = BatchSampler(range(21 ) , batch_size=4 , drop_last=A ) UpperCAmelCase : Optional[int] = [ [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]], [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]], ] self.check_batch_sampler_shards(A , A , split_batches=A ) # Check the shards when the dataset is very small. UpperCAmelCase : Optional[int] = BatchSampler(range(2 ) , batch_size=4 , drop_last=A ) UpperCAmelCase : Optional[Any] = [[[0, 1]], [[0, 1]]] self.check_batch_sampler_shards(A , A , split_batches=A ) UpperCAmelCase : Dict = BatchSampler(range(2 ) , batch_size=4 , drop_last=A ) UpperCAmelCase : Any = [[], []] self.check_batch_sampler_shards(A , A , split_batches=A ) def _lowercase( self ) -> Any: # Check the shards when the dataset is a round multiple of total batch size. UpperCAmelCase : str = BatchSampler(range(24 ) , batch_size=3 , drop_last=A ) UpperCAmelCase : Optional[Any] = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]], [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21, 22, 23]], ] self.check_batch_sampler_shards(A , A , even_batches=A ) UpperCAmelCase : Union[str, Any] = BatchSampler(range(24 ) , batch_size=3 , drop_last=A ) # Expected shouldn't change self.check_batch_sampler_shards(A , A , even_batches=A ) # Check the shards when the dataset is a round multiple of batch size but not total batch size. UpperCAmelCase : Optional[Any] = BatchSampler(range(21 ) , batch_size=3 , drop_last=A ) UpperCAmelCase : Optional[int] = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]], [[3, 4, 5], [9, 10, 11], [15, 16, 17]], ] self.check_batch_sampler_shards(A , A , even_batches=A ) UpperCAmelCase : str = BatchSampler(range(21 ) , batch_size=3 , drop_last=A ) UpperCAmelCase : List[Any] = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14]], [[3, 4, 5], [9, 10, 11], [15, 16, 17]], ] self.check_batch_sampler_shards(A , A , even_batches=A ) # Check the shards when the dataset is not a round multiple of batch size but has a multiple of # num_processes batch. UpperCAmelCase : List[Any] = BatchSampler(range(22 ) , batch_size=3 , drop_last=A ) UpperCAmelCase : Dict = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]], [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21]], ] self.check_batch_sampler_shards(A , A , even_batches=A ) UpperCAmelCase : Dict = BatchSampler(range(22 ) , batch_size=3 , drop_last=A ) UpperCAmelCase : Optional[Any] = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14]], [[3, 4, 5], [9, 10, 11], [15, 16, 17]], ] self.check_batch_sampler_shards(A , A , even_batches=A ) # Check the shards when the dataset is not a round multiple of batch size but and has not a multiple of # num_processes batch. UpperCAmelCase : List[str] = BatchSampler(range(20 ) , batch_size=3 , drop_last=A ) UpperCAmelCase : Union[str, Any] = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19]], [[3, 4, 5], [9, 10, 11], [15, 16, 17]], ] self.check_batch_sampler_shards(A , A , even_batches=A ) UpperCAmelCase : Optional[int] = BatchSampler(range(20 ) , batch_size=3 , drop_last=A ) UpperCAmelCase : Optional[Any] = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14]], [[3, 4, 5], [9, 10, 11], [15, 16, 17]], ] self.check_batch_sampler_shards(A , A , even_batches=A ) # Check the shards when the dataset is very small. UpperCAmelCase : Dict = BatchSampler(range(2 ) , batch_size=3 , drop_last=A ) UpperCAmelCase : str = [[[0, 1]], []] self.check_batch_sampler_shards(A , A , even_batches=A ) UpperCAmelCase : List[str] = BatchSampler(range(2 ) , batch_size=3 , drop_last=A ) UpperCAmelCase : Tuple = [[], []] self.check_batch_sampler_shards(A , A , even_batches=A ) def _lowercase( self ) -> List[Any]: # Check the shards when the dataset is a round multiple of batch size. UpperCAmelCase : Dict = BatchSampler(range(24 ) , batch_size=4 , drop_last=A ) UpperCAmelCase : List[Any] = [ [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]], [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [22, 23]], ] self.check_batch_sampler_shards(A , A , split_batches=A , even_batches=A ) UpperCAmelCase : int = BatchSampler(range(24 ) , batch_size=4 , drop_last=A ) # Expected shouldn't change self.check_batch_sampler_shards(A , A , split_batches=A , even_batches=A ) # Check the shards when the dataset is not a round multiple of batch size. UpperCAmelCase : List[str] = BatchSampler(range(22 ) , batch_size=4 , drop_last=A ) UpperCAmelCase : Optional[Any] = [ [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]], [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]], ] self.check_batch_sampler_shards(A , A , split_batches=A , even_batches=A ) UpperCAmelCase : Dict = BatchSampler(range(22 ) , batch_size=4 , drop_last=A ) UpperCAmelCase : Dict = [ [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]], [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]], ] self.check_batch_sampler_shards(A , A , split_batches=A , even_batches=A ) # Check the shards when the dataset is not a round multiple of batch size or num_processes. UpperCAmelCase : Dict = BatchSampler(range(21 ) , batch_size=4 , drop_last=A ) UpperCAmelCase : Union[str, Any] = [ [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20]], [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]], ] self.check_batch_sampler_shards(A , A , split_batches=A , even_batches=A ) UpperCAmelCase : Any = BatchSampler(range(21 ) , batch_size=4 , drop_last=A ) UpperCAmelCase : Dict = [ [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]], [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]], ] self.check_batch_sampler_shards(A , A , split_batches=A , even_batches=A ) # Check the shards when the dataset is very small. UpperCAmelCase : str = BatchSampler(range(2 ) , batch_size=4 , drop_last=A ) UpperCAmelCase : Dict = [[[0, 1]], []] self.check_batch_sampler_shards(A , A , split_batches=A , even_batches=A ) UpperCAmelCase : Any = BatchSampler(range(2 ) , batch_size=4 , drop_last=A ) UpperCAmelCase : Dict = [[], []] self.check_batch_sampler_shards(A , A , split_batches=A , even_batches=A ) def _lowercase( self ) -> Optional[int]: UpperCAmelCase : Optional[int] = [[0, 1, 2], [3, 4], [5, 6, 7, 8], [9, 10, 11], [12, 13]] UpperCAmelCase : List[str] = [BatchSamplerShard(A , 2 , A , even_batches=A ) for i in range(2 )] self.assertEqual(len(batch_sampler_shards[0] ) , 3 ) self.assertEqual(len(batch_sampler_shards[1] ) , 2 ) self.assertListEqual(list(batch_sampler_shards[0] ) , [[0, 1, 2], [5, 6, 7, 8], [12, 13]] ) self.assertListEqual(list(batch_sampler_shards[1] ) , [[3, 4], [9, 10, 11]] ) def _lowercase( self , A , A , A , A=False , A=2 , A=False ) -> Tuple: random.seed(A ) UpperCAmelCase : Dict = list(A ) UpperCAmelCase : Any = [ IterableDatasetShard( A , batch_size=A , drop_last=A , num_processes=A , process_index=A , split_batches=A , ) for i in range(A ) ] UpperCAmelCase : Dict = [] for iterable_dataset_shard in iterable_dataset_shards: # Since our random iterable dataset will be... random... we need to use a seed to get reproducible results. random.seed(A ) iterable_dataset_lists.append(list(A ) ) UpperCAmelCase : Optional[Any] = batch_size // num_processes if split_batches else batch_size # All iterable dataset shard should have the same length, a round multiple of shard_batch_size UpperCAmelCase : List[Any] = iterable_dataset_lists[0] for l in iterable_dataset_lists[1:]: self.assertEqual(len(A ) , len(A ) ) self.assertTrue(len(A ) % shard_batch_size == 0 ) UpperCAmelCase : List[Any] = [] for idx in range(0 , len(A ) , A ): for l in iterable_dataset_lists: observed += l[idx : idx + shard_batch_size] if not drop_last: while len(A ) < len(A ): reference += reference self.assertListEqual(A , reference[: len(A )] ) def _lowercase( self ) -> str: UpperCAmelCase : Tuple = 42 UpperCAmelCase : List[Any] = RandomIterableDataset() self.check_iterable_dataset_shards(A , A , batch_size=4 , drop_last=A , split_batches=A ) self.check_iterable_dataset_shards(A , A , batch_size=4 , drop_last=A , split_batches=A ) self.check_iterable_dataset_shards(A , A , batch_size=4 , drop_last=A , split_batches=A ) self.check_iterable_dataset_shards(A , A , batch_size=4 , drop_last=A , split_batches=A ) # Edge case with a very small dataset UpperCAmelCase : List[Any] = RandomIterableDataset(max_length=2 ) self.check_iterable_dataset_shards(A , A , batch_size=4 , drop_last=A , split_batches=A ) self.check_iterable_dataset_shards(A , A , batch_size=4 , drop_last=A , split_batches=A ) self.check_iterable_dataset_shards(A , A , batch_size=4 , drop_last=A , split_batches=A ) self.check_iterable_dataset_shards(A , A , batch_size=4 , drop_last=A , split_batches=A ) def _lowercase( self ) -> Tuple: UpperCAmelCase : Dict = BatchSampler(range(16 ) , batch_size=4 , drop_last=A ) UpperCAmelCase : Any = SkipBatchSampler(A , 2 ) self.assertListEqual(list(A ) , [[8, 9, 10, 11], [12, 13, 14, 15]] ) def _lowercase( self ) -> int: UpperCAmelCase : Any = SkipDataLoader(list(range(16 ) ) , batch_size=4 , skip_batches=2 ) self.assertListEqual([t.tolist() for t in dataloader] , [[8, 9, 10, 11], [12, 13, 14, 15]] ) def _lowercase( self ) -> Union[str, Any]: UpperCAmelCase : List[Any] = DataLoader(list(range(16 ) ) , batch_size=4 ) UpperCAmelCase : Optional[Any] = skip_first_batches(A , num_batches=2 ) self.assertListEqual([t.tolist() for t in new_dataloader] , [[8, 9, 10, 11], [12, 13, 14, 15]] ) def _lowercase( self ) -> Optional[Any]: UpperCAmelCase : Optional[int] = DataLoaderShard(list(range(16 ) ) , batch_size=4 ) for idx, _ in enumerate(A ): self.assertEqual(dataloader.end_of_dataloader , idx == 3 ) # Test it also works on the second iteration for idx, _ in enumerate(A ): self.assertEqual(dataloader.end_of_dataloader , idx == 3 ) def _lowercase( self ) -> Dict: Accelerator() UpperCAmelCase : Union[str, Any] = DataLoaderDispatcher(range(16 ) , batch_size=4 ) for idx, _ in enumerate(A ): self.assertEqual(dataloader.end_of_dataloader , idx == 3 ) # Test it also works on the second iteration for idx, _ in enumerate(A ): self.assertEqual(dataloader.end_of_dataloader , idx == 3 )

'''simple docstring''' import pytest from datasets.splits import SplitDict, SplitInfo from datasets.utils.py_utils import asdict @pytest.mark.parametrize( """split_dict""" , [ SplitDict(), SplitDict({"""train""": SplitInfo(name="""train""" , num_bytes=1_3_3_7 , num_examples=4_2 , dataset_name="""my_dataset""" )} ), SplitDict({"""train""": SplitInfo(name="""train""" , num_bytes=1_3_3_7 , num_examples=4_2 )} ), SplitDict({"""train""": SplitInfo()} ), ] , ) def __lowerCamelCase ( _lowercase ) -> List[str]: UpperCAmelCase : Optional[int] = split_dict._to_yaml_list() assert len(_lowercase ) == len(_lowercase ) UpperCAmelCase : List[Any] = SplitDict._from_yaml_list(_lowercase ) for split_name, split_info in split_dict.items(): # dataset_name field is deprecated, and is therefore not part of the YAML dump UpperCAmelCase : List[str] = None # the split name of split_dict takes over the name of the split info object UpperCAmelCase : int = split_name assert split_dict == reloaded @pytest.mark.parametrize( """split_info""" , [SplitInfo(), SplitInfo(dataset_name=_lowercase ), SplitInfo(dataset_name="""my_dataset""" )] ) def __lowerCamelCase ( _lowercase ) -> List[str]: # For backward compatibility, we need asdict(split_dict) to return split info dictrionaries with the "dataset_name" # field even if it's deprecated. This way old versionso of `datasets` can still reload dataset_infos.json files UpperCAmelCase : Optional[Any] = asdict(SplitDict({"""train""": split_info} ) ) assert "dataset_name" in split_dict_asdict["train"] assert split_dict_asdict["train"]["dataset_name"] == split_info.dataset_name

"""simple docstring""" import json import os import tempfile import datasets from utils import generate_example_dataset, get_duration lowercase__ = 5_0000 lowercase__ = 5000 lowercase__ , lowercase__ = os.path.split(__file__) lowercase__ = os.path.join(RESULTS_BASEPATH, """results""", RESULTS_FILENAME.replace(""".py""", """.json""")) @get_duration def _snake_case ( lowercase__ , lowercase__ ): for i in range(lowercase__ ): _lowerCamelCase : Optional[Any] = dataset[i] @get_duration def _snake_case ( lowercase__ , lowercase__ , lowercase__ ): for i in range(0 , len(lowercase__ ) , lowercase__ ): _lowerCamelCase : str = dataset[i : i + batch_size] @get_duration def _snake_case ( lowercase__ , lowercase__ , lowercase__ ): with dataset.formatted_as(type=lowercase__ ): for i in range(lowercase__ ): _lowerCamelCase : Optional[Any] = dataset[i] @get_duration def _snake_case ( lowercase__ , lowercase__ , lowercase__ , lowercase__ ): with dataset.formatted_as(type=lowercase__ ): for i in range(0 , lowercase__ , lowercase__ ): _lowerCamelCase : Tuple = dataset[i : i + batch_size] def _snake_case ( ): _lowerCamelCase : List[str] = {'num examples': SPEED_TEST_N_EXAMPLES} _lowerCamelCase : str = [ (read, {'length': SMALL_TEST}), (read, {'length': SPEED_TEST_N_EXAMPLES}), (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 10}), (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 100}), (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 1000}), (read_formatted, {'type': 'numpy', 'length': SMALL_TEST}), (read_formatted, {'type': 'pandas', 'length': SMALL_TEST}), (read_formatted, {'type': 'torch', 'length': SMALL_TEST}), (read_formatted, {'type': 'tensorflow', 'length': SMALL_TEST}), (read_formatted_batch, {'type': 'numpy', 'length': SMALL_TEST, 'batch_size': 10}), (read_formatted_batch, {'type': 'numpy', 'length': SMALL_TEST, 'batch_size': 1000}), ] _lowerCamelCase : Dict = [ (read, {'length': SMALL_TEST}), (read, {'length': SPEED_TEST_N_EXAMPLES}), (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 10}), (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 100}), (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 1000}), (read_formatted, {'type': 'numpy', 'length': SMALL_TEST}), (read_formatted_batch, {'type': 'numpy', 'length': SMALL_TEST, 'batch_size': 10}), (read_formatted_batch, {'type': 'numpy', 'length': SMALL_TEST, 'batch_size': 1000}), ] with tempfile.TemporaryDirectory() as tmp_dir: print('generating dataset' ) _lowerCamelCase : List[Any] = datasets.Features( {'list': datasets.Sequence(datasets.Value('float32' ) ), 'numbers': datasets.Value('float32' )} ) _lowerCamelCase : List[Any] = generate_example_dataset( os.path.join(lowercase__ , 'dataset.arrow' ) , lowercase__ , num_examples=lowercase__ , seq_shapes={'list': (100,)} , ) print('first set of iterations' ) for func, kwargs in functions: print(func.__name__ , str(lowercase__ ) ) _lowerCamelCase : int = func(lowercase__ , **lowercase__ ) print('shuffling dataset' ) _lowerCamelCase : Dict = dataset.shuffle() print('Second set of iterations (after shuffling' ) for func, kwargs in functions_shuffled: print('shuffled ' , func.__name__ , str(lowercase__ ) ) _lowerCamelCase : List[str] = func( lowercase__ , **lowercase__ ) with open(lowercase__ , 'wb' ) as f: f.write(json.dumps(lowercase__ ).encode('utf-8' ) ) if __name__ == "__main__": # useful to run the profiler benchmark_iterating()

'''simple docstring''' import collections import tempfile import unittest import numpy as np from transformers.testing_utils import ( is_pt_flax_cross_test, require_flax, require_torch, require_vision, slow, torch_device, ) from transformers.utils import is_flax_available, is_torch_available, is_vision_available from ...test_modeling_flax_common import floats_tensor, ids_tensor, random_attention_mask from ..bert.test_modeling_flax_bert import FlaxBertModelTester from ..clip.test_modeling_flax_clip import FlaxCLIPVisionModelTester from ..vit.test_modeling_flax_vit import FlaxViTModelTester if is_flax_available(): from transformers import ( FlaxBertModel, FlaxCLIPVisionModel, FlaxVisionTextDualEncoderModel, FlaxViTModel, VisionTextDualEncoderConfig, VisionTextDualEncoderProcessor, ) from transformers.modeling_flax_pytorch_utils import ( convert_pytorch_state_dict_to_flax, load_flax_weights_in_pytorch_model, ) if is_torch_available(): import torch from transformers import VisionTextDualEncoderModel if is_vision_available(): from PIL import Image def a__ ( lowercase : Union[str, Any] ) -> Tuple: """simple docstring""" if isinstance(lowercase, collections.abc.Iterable ): return x return (x, x) @require_flax class __lowerCAmelCase : """simple docstring""" def snake_case__ ( self : Any , lowerCAmelCase__ : Dict , lowerCAmelCase__ : str ) -> List[Any]: '''simple docstring''' pass def snake_case__ ( self : Tuple ) -> int: '''simple docstring''' pass def snake_case__ ( self : Any ) -> Optional[int]: '''simple docstring''' pass def snake_case__ ( self : int , lowerCAmelCase__ : np.ndarray , lowerCAmelCase__ : np.ndarray , lowerCAmelCase__ : float ) -> str: '''simple docstring''' _UpperCamelCase = np.abs((a - b) ).max() self.assertLessEqual(lowerCAmelCase__ , lowerCAmelCase__ , f"""Difference between torch and flax is {diff} (>= {tol}).""" ) def snake_case__ ( self : List[str] , lowerCAmelCase__ : Optional[int] , lowerCAmelCase__ : Dict , lowerCAmelCase__ : int , lowerCAmelCase__ : Optional[int] , lowerCAmelCase__ : str=None , **lowerCAmelCase__ : Union[str, Any] ) -> Dict: '''simple docstring''' _UpperCamelCase = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCAmelCase__ , lowerCAmelCase__ ) _UpperCamelCase = FlaxVisionTextDualEncoderModel(lowerCAmelCase__ ) _UpperCamelCase = model(input_ids=lowerCAmelCase__ , pixel_values=lowerCAmelCase__ , attention_mask=lowerCAmelCase__ ) self.assertEqual(output['''text_embeds'''].shape , (input_ids.shape[0], config.projection_dim) ) self.assertEqual(output['''image_embeds'''].shape , (pixel_values.shape[0], config.projection_dim) ) def snake_case__ ( self : str , lowerCAmelCase__ : str , lowerCAmelCase__ : int , lowerCAmelCase__ : Optional[int] , lowerCAmelCase__ : str , lowerCAmelCase__ : List[Any]=None , **lowerCAmelCase__ : Any ) -> List[Any]: '''simple docstring''' _UpperCamelCase , _UpperCamelCase = self.get_vision_text_model(lowerCAmelCase__ , lowerCAmelCase__ ) _UpperCamelCase = {'''vision_model''': vision_model, '''text_model''': text_model} _UpperCamelCase = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCAmelCase__ ) _UpperCamelCase = model(input_ids=lowerCAmelCase__ , pixel_values=lowerCAmelCase__ , attention_mask=lowerCAmelCase__ ) self.assertEqual(output['''text_embeds'''].shape , (input_ids.shape[0], model.config.projection_dim) ) self.assertEqual(output['''image_embeds'''].shape , (pixel_values.shape[0], model.config.projection_dim) ) def snake_case__ ( self : str , lowerCAmelCase__ : Tuple , lowerCAmelCase__ : Dict , lowerCAmelCase__ : List[str] , lowerCAmelCase__ : Tuple , lowerCAmelCase__ : List[Any]=None , **lowerCAmelCase__ : Union[str, Any] ) -> Dict: '''simple docstring''' _UpperCamelCase , _UpperCamelCase = self.get_vision_text_model(lowerCAmelCase__ , lowerCAmelCase__ ) _UpperCamelCase = {'''vision_model''': vision_model, '''text_model''': text_model} _UpperCamelCase = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCAmelCase__ ) _UpperCamelCase = model(input_ids=lowerCAmelCase__ , pixel_values=lowerCAmelCase__ , attention_mask=lowerCAmelCase__ ) _UpperCamelCase = output[0] with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(lowerCAmelCase__ ) _UpperCamelCase = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCAmelCase__ ) _UpperCamelCase = model(input_ids=lowerCAmelCase__ , pixel_values=lowerCAmelCase__ , attention_mask=lowerCAmelCase__ ) _UpperCamelCase = after_output[0] _UpperCamelCase = np.amax(np.abs(out_a - out_a ) ) self.assertLessEqual(lowerCAmelCase__ , 1e-3 ) def snake_case__ ( self : Optional[int] , lowerCAmelCase__ : List[Any] , lowerCAmelCase__ : List[str] , lowerCAmelCase__ : Union[str, Any] , lowerCAmelCase__ : Optional[int] , lowerCAmelCase__ : str=None , **lowerCAmelCase__ : Optional[int] ) -> Any: '''simple docstring''' _UpperCamelCase , _UpperCamelCase = self.get_vision_text_model(lowerCAmelCase__ , lowerCAmelCase__ ) _UpperCamelCase = {'''vision_model''': vision_model, '''text_model''': text_model} _UpperCamelCase = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCAmelCase__ ) _UpperCamelCase = model( input_ids=lowerCAmelCase__ , pixel_values=lowerCAmelCase__ , attention_mask=lowerCAmelCase__ , output_attentions=lowerCAmelCase__ ) _UpperCamelCase = output.vision_model_output.attentions self.assertEqual(len(lowerCAmelCase__ ) , vision_config.num_hidden_layers ) # in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token) _UpperCamelCase = to_atuple(vision_model.config.image_size ) _UpperCamelCase = to_atuple(vision_model.config.patch_size ) _UpperCamelCase = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0]) _UpperCamelCase = num_patches + 1 self.assertEqual(vision_attentions[0].shape[-3:] , (vision_config.num_attention_heads, seq_len, seq_len) ) _UpperCamelCase = output.text_model_output.attentions self.assertEqual(len(lowerCAmelCase__ ) , text_config.num_hidden_layers ) self.assertEqual( text_attentions[0].shape[-3:] , (text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1]) , ) def snake_case__ ( self : List[Any] , lowerCAmelCase__ : Union[str, Any] , lowerCAmelCase__ : Tuple , lowerCAmelCase__ : int ) -> Tuple: '''simple docstring''' pt_model.to(lowerCAmelCase__ ) pt_model.eval() # prepare inputs _UpperCamelCase = inputs_dict _UpperCamelCase = {k: torch.tensor(v.tolist() ) for k, v in flax_inputs.items()} with torch.no_grad(): _UpperCamelCase = pt_model(**lowerCAmelCase__ ).to_tuple() _UpperCamelCase = fx_model(**lowerCAmelCase__ ).to_tuple() self.assertEqual(len(lowerCAmelCase__ ) , len(lowerCAmelCase__ ) , '''Output lengths differ between Flax and PyTorch''' ) for fx_output, pt_output in zip(fx_outputs[:4] , pt_outputs[:4] ): self.assert_almost_equals(lowerCAmelCase__ , pt_output.numpy() , 4e-2 ) # PT -> Flax with tempfile.TemporaryDirectory() as tmpdirname: pt_model.save_pretrained(lowerCAmelCase__ ) _UpperCamelCase = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCAmelCase__ , from_pt=lowerCAmelCase__ ) _UpperCamelCase = fx_model_loaded(**lowerCAmelCase__ ).to_tuple() self.assertEqual(len(lowerCAmelCase__ ) , len(lowerCAmelCase__ ) , '''Output lengths differ between Flax and PyTorch''' ) for fx_output_loaded, pt_output in zip(fx_outputs_loaded[:4] , pt_outputs[:4] ): self.assert_almost_equals(lowerCAmelCase__ , pt_output.numpy() , 4e-2 ) # Flax -> PT with tempfile.TemporaryDirectory() as tmpdirname: fx_model.save_pretrained(lowerCAmelCase__ ) _UpperCamelCase = VisionTextDualEncoderModel.from_pretrained(lowerCAmelCase__ , from_flax=lowerCAmelCase__ ) pt_model_loaded.to(lowerCAmelCase__ ) pt_model_loaded.eval() with torch.no_grad(): _UpperCamelCase = pt_model_loaded(**lowerCAmelCase__ ).to_tuple() self.assertEqual(len(lowerCAmelCase__ ) , len(lowerCAmelCase__ ) , '''Output lengths differ between Flax and PyTorch''' ) for fx_output, pt_output_loaded in zip(fx_outputs[:4] , pt_outputs_loaded[:4] ): self.assert_almost_equals(lowerCAmelCase__ , pt_output_loaded.numpy() , 4e-2 ) def snake_case__ ( self : Dict , lowerCAmelCase__ : List[Any] , lowerCAmelCase__ : Optional[int] , lowerCAmelCase__ : int ) -> Any: '''simple docstring''' _UpperCamelCase = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCAmelCase__ , lowerCAmelCase__ ) _UpperCamelCase = VisionTextDualEncoderModel(lowerCAmelCase__ ) _UpperCamelCase = FlaxVisionTextDualEncoderModel(lowerCAmelCase__ ) _UpperCamelCase = convert_pytorch_state_dict_to_flax(pt_model.state_dict() , lowerCAmelCase__ ) _UpperCamelCase = fx_state self.check_pt_flax_equivalence(lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ ) def snake_case__ ( self : Any , lowerCAmelCase__ : Union[str, Any] , lowerCAmelCase__ : Tuple , lowerCAmelCase__ : List[Any] ) -> str: '''simple docstring''' _UpperCamelCase = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCAmelCase__ , lowerCAmelCase__ ) _UpperCamelCase = VisionTextDualEncoderModel(lowerCAmelCase__ ) _UpperCamelCase = FlaxVisionTextDualEncoderModel(lowerCAmelCase__ ) _UpperCamelCase = load_flax_weights_in_pytorch_model(lowerCAmelCase__ , fx_model.params ) self.check_pt_flax_equivalence(lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ ) def snake_case__ ( self : List[Any] ) -> Optional[Any]: '''simple docstring''' _UpperCamelCase = self.prepare_config_and_inputs() self.check_model_from_pretrained_configs(**lowerCAmelCase__ ) def snake_case__ ( self : List[Any] ) -> int: '''simple docstring''' _UpperCamelCase = self.prepare_config_and_inputs() self.check_vision_text_dual_encoder_from_pretrained(**lowerCAmelCase__ ) def snake_case__ ( self : Union[str, Any] ) -> Optional[int]: '''simple docstring''' _UpperCamelCase = self.prepare_config_and_inputs() self.check_save_load(**lowerCAmelCase__ ) def snake_case__ ( self : Any ) -> Tuple: '''simple docstring''' _UpperCamelCase = self.prepare_config_and_inputs() self.check_vision_text_output_attention(**lowerCAmelCase__ ) @is_pt_flax_cross_test def snake_case__ ( self : int ) -> List[Any]: '''simple docstring''' _UpperCamelCase = self.prepare_config_and_inputs() _UpperCamelCase = config_inputs_dict.pop('''vision_config''' ) _UpperCamelCase = config_inputs_dict.pop('''text_config''' ) _UpperCamelCase = config_inputs_dict self.check_equivalence_pt_to_flax(lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ ) self.check_equivalence_flax_to_pt(lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ ) @slow def snake_case__ ( self : List[Any] ) -> Any: '''simple docstring''' _UpperCamelCase , _UpperCamelCase = self.get_pretrained_model_and_inputs() _UpperCamelCase = model_a(**lowerCAmelCase__ ) _UpperCamelCase = outputs[0] with tempfile.TemporaryDirectory() as tmp_dirname: model_a.save_pretrained(lowerCAmelCase__ ) _UpperCamelCase = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCAmelCase__ ) _UpperCamelCase = model_a(**lowerCAmelCase__ ) _UpperCamelCase = after_outputs[0] _UpperCamelCase = np.amax(np.abs(out_a - out_a ) ) self.assertLessEqual(lowerCAmelCase__ , 1e-5 ) @require_flax class __lowerCAmelCase ( __magic_name__ , unittest.TestCase ): """simple docstring""" def snake_case__ ( self : Tuple ) -> List[str]: '''simple docstring''' _UpperCamelCase = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained( '''hf-internal-testing/tiny-random-vit''' , '''hf-internal-testing/tiny-bert''' , vision_from_pt=lowerCAmelCase__ , text_from_pt=lowerCAmelCase__ , ) _UpperCamelCase = 13 _UpperCamelCase = floats_tensor( [ batch_size, model.config.vision_config.num_channels, model.config.vision_config.image_size, model.config.vision_config.image_size, ] ) _UpperCamelCase = ids_tensor([batch_size, 4] , model.config.text_config.vocab_size ) _UpperCamelCase = random_attention_mask([batch_size, 4] ) _UpperCamelCase = {'''pixel_values''': pixel_values, '''input_ids''': input_ids, '''attention_mask''': attention_mask} return model, inputs def snake_case__ ( self : int , lowerCAmelCase__ : List[str] , lowerCAmelCase__ : Union[str, Any] ) -> Any: '''simple docstring''' _UpperCamelCase = FlaxViTModel(lowerCAmelCase__ ) _UpperCamelCase = FlaxBertModel(lowerCAmelCase__ ) return vision_model, text_model def snake_case__ ( self : str ) -> Tuple: '''simple docstring''' _UpperCamelCase = FlaxViTModelTester(self ) _UpperCamelCase = FlaxBertModelTester(self ) _UpperCamelCase = vit_model_tester.prepare_config_and_inputs() _UpperCamelCase = bert_model_tester.prepare_config_and_inputs() _UpperCamelCase , _UpperCamelCase = vision_config_and_inputs _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase = text_config_and_inputs # make sure that cross attention layers are added return { "text_config": text_config, "vision_config": vision_config, "pixel_values": pixel_values, "attention_mask": attention_mask, "input_ids": input_ids, "token_type_ids": token_type_ids, } @require_torch class __lowerCAmelCase ( __magic_name__ , unittest.TestCase ): """simple docstring""" def snake_case__ ( self : List[str] ) -> List[str]: '''simple docstring''' _UpperCamelCase = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained( '''hf-internal-testing/tiny-random-clip''' , '''hf-internal-testing/tiny-bert''' , vision_from_pt=lowerCAmelCase__ , text_from_pt=lowerCAmelCase__ , ) _UpperCamelCase = 13 _UpperCamelCase = floats_tensor( [ batch_size, model.config.vision_config.num_channels, model.config.vision_config.image_size, model.config.vision_config.image_size, ] ) _UpperCamelCase = ids_tensor([batch_size, 4] , model.config.text_config.vocab_size ) _UpperCamelCase = random_attention_mask([batch_size, 4] ) _UpperCamelCase = {'''pixel_values''': pixel_values, '''input_ids''': input_ids, '''attention_mask''': attention_mask} return model, inputs def snake_case__ ( self : Union[str, Any] , lowerCAmelCase__ : Dict , lowerCAmelCase__ : Union[str, Any] ) -> List[str]: '''simple docstring''' _UpperCamelCase = FlaxCLIPVisionModel(lowerCAmelCase__ ) _UpperCamelCase = FlaxBertModel(lowerCAmelCase__ ) return vision_model, text_model def snake_case__ ( self : List[str] ) -> Dict: '''simple docstring''' _UpperCamelCase = FlaxCLIPVisionModelTester(self ) _UpperCamelCase = FlaxBertModelTester(self ) _UpperCamelCase = clip_model_tester.prepare_config_and_inputs() _UpperCamelCase = bert_model_tester.prepare_config_and_inputs() _UpperCamelCase , _UpperCamelCase = vision_config_and_inputs _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase = text_config_and_inputs # make sure that cross attention layers are added return { "text_config": text_config, "vision_config": vision_config, "pixel_values": pixel_values, "attention_mask": attention_mask, "input_ids": input_ids, "token_type_ids": token_type_ids, } @require_flax @require_vision class __lowerCAmelCase ( unittest.TestCase ): """simple docstring""" @slow def snake_case__ ( self : List[Any] ) -> Any: '''simple docstring''' _UpperCamelCase = FlaxVisionTextDualEncoderModel.from_pretrained('''clip-italian/clip-italian''' , logit_scale_init_value=1.0 ) _UpperCamelCase = VisionTextDualEncoderProcessor.from_pretrained('''clip-italian/clip-italian''' ) _UpperCamelCase = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' ) _UpperCamelCase = processor( text=['''una foto di un gatto''', '''una foto di un cane'''] , images=lowerCAmelCase__ , padding=lowerCAmelCase__ , return_tensors='''np''' ) _UpperCamelCase = model(**lowerCAmelCase__ ) # verify the logits self.assertEqual(outputs.logits_per_image.shape , (inputs.pixel_values.shape[0], inputs.input_ids.shape[0]) ) self.assertEqual( outputs.logits_per_text.shape , (inputs.input_ids.shape[0], inputs.pixel_values.shape[0]) , ) _UpperCamelCase = np.array([[1.2284727, 0.3104122]] ) self.assertTrue(np.allclose(outputs.logits_per_image , lowerCAmelCase__ , atol=1e-3 ) )

import io import itertools import json from dataclasses import dataclass from typing import Optional import pyarrow as pa import pyarrow.json as paj import datasets from datasets.table import table_cast from datasets.utils.file_utils import readline _SCREAMING_SNAKE_CASE : List[str] = datasets.utils.logging.get_logger(__name__) @dataclass class A__ ( datasets.BuilderConfig ): """simple docstring""" __magic_name__ = None __magic_name__ = "utf-8" __magic_name__ = None __magic_name__ = None __magic_name__ = True # deprecated __magic_name__ = None # deprecated __magic_name__ = 10 << 20 # 10MB __magic_name__ = None class A__ ( datasets.ArrowBasedBuilder ): """simple docstring""" __magic_name__ = JsonConfig def a_ ( self ): if self.config.block_size is not None: logger.warning('''The JSON loader parameter `block_size` is deprecated. Please use `chunksize` instead''' ) snake_case = self.config.block_size if self.config.use_threads is not True: logger.warning( '''The JSON loader parameter `use_threads` is deprecated and doesn\'t have any effect anymore.''' ) if self.config.newlines_in_values is not None: raise ValueError('''The JSON loader parameter `newlines_in_values` is no longer supported''' ) return datasets.DatasetInfo(features=self.config.features ) def a_ ( self , __snake_case ): if not self.config.data_files: raise ValueError(F'''At least one data file must be specified, but got data_files={self.config.data_files}''' ) snake_case = dl_manager.download_and_extract(self.config.data_files ) if isinstance(__snake_case , (str, list, tuple) ): snake_case = data_files if isinstance(__snake_case , __snake_case ): snake_case = [files] snake_case = [dl_manager.iter_files(__snake_case ) for file in files] return [datasets.SplitGenerator(name=datasets.Split.TRAIN , gen_kwargs={'''files''': files} )] snake_case = [] for split_name, files in data_files.items(): if isinstance(__snake_case , __snake_case ): snake_case = [files] snake_case = [dl_manager.iter_files(__snake_case ) for file in files] splits.append(datasets.SplitGenerator(name=__snake_case , gen_kwargs={'''files''': files} ) ) return splits def a_ ( self , __snake_case ): if self.config.features is not None: # adding missing columns for column_name in set(self.config.features ) - set(pa_table.column_names ): snake_case = self.config.features.arrow_schema.field(__snake_case ).type snake_case = pa_table.append_column(__snake_case , pa.array([None] * len(__snake_case ) , type=__snake_case ) ) # more expensive cast to support nested structures with keys in a different order # allows str <-> int/float or str to Audio for example snake_case = table_cast(__snake_case , self.config.features.arrow_schema ) return pa_table def a_ ( self , __snake_case ): for file_idx, file in enumerate(itertools.chain.from_iterable(__snake_case ) ): # If the file is one json object and if we need to look at the list of items in one specific field if self.config.field is not None: with open(__snake_case , encoding=self.config.encoding , errors=self.config.encoding_errors ) as f: snake_case = json.load(__snake_case ) # We keep only the field we are interested in snake_case = dataset[self.config.field] # We accept two format: a list of dicts or a dict of lists if isinstance(__snake_case , (list, tuple) ): snake_case = set().union(*[row.keys() for row in dataset] ) snake_case = {col: [row.get(__snake_case ) for row in dataset] for col in keys} else: snake_case = dataset snake_case = pa.Table.from_pydict(__snake_case ) yield file_idx, self._cast_table(__snake_case ) # If the file has one json object per line else: with open(__snake_case , '''rb''' ) as f: snake_case = 0 # Use block_size equal to the chunk size divided by 32 to leverage multithreading # Set a default minimum value of 16kB if the chunk size is really small snake_case = max(self.config.chunksize // 3_2 , 1_6 << 1_0 ) snake_case = ( self.config.encoding_errors if self.config.encoding_errors is not None else '''strict''' ) while True: snake_case = f.read(self.config.chunksize ) if not batch: break # Finish current line try: batch += f.readline() except (AttributeError, io.UnsupportedOperation): batch += readline(__snake_case ) # PyArrow only accepts utf-8 encoded bytes if self.config.encoding != "utf-8": snake_case = batch.decode(self.config.encoding , errors=__snake_case ).encode('''utf-8''' ) try: while True: try: snake_case = paj.read_json( io.BytesIO(__snake_case ) , read_options=paj.ReadOptions(block_size=__snake_case ) ) break except (pa.ArrowInvalid, pa.ArrowNotImplementedError) as e: if ( isinstance(__snake_case , pa.ArrowInvalid ) and "straddling" not in str(__snake_case ) or block_size > len(__snake_case ) ): raise else: # Increase the block size in case it was too small. # The block size will be reset for the next file. logger.debug( F'''Batch of {len(__snake_case )} bytes couldn\'t be parsed with block_size={block_size}. Retrying with block_size={block_size * 2}.''' ) block_size *= 2 except pa.ArrowInvalid as e: try: with open( __snake_case , encoding=self.config.encoding , errors=self.config.encoding_errors ) as f: snake_case = json.load(__snake_case ) except json.JSONDecodeError: logger.error(F'''Failed to read file \'{file}\' with error {type(__snake_case )}: {e}''' ) raise e # If possible, parse the file as a list of json objects and exit the loop if isinstance(__snake_case , __snake_case ): # list is the only sequence type supported in JSON try: snake_case = set().union(*[row.keys() for row in dataset] ) snake_case = {col: [row.get(__snake_case ) for row in dataset] for col in keys} snake_case = pa.Table.from_pydict(__snake_case ) except (pa.ArrowInvalid, AttributeError) as e: logger.error(F'''Failed to read file \'{file}\' with error {type(__snake_case )}: {e}''' ) raise ValueError(F'''Not able to read records in the JSON file at {file}.''' ) from None yield file_idx, self._cast_table(__snake_case ) break else: logger.error(F'''Failed to read file \'{file}\' with error {type(__snake_case )}: {e}''' ) raise ValueError( F'''Not able to read records in the JSON file at {file}. ''' F'''You should probably indicate the field of the JSON file containing your records. ''' F'''This JSON file contain the following fields: {str(list(dataset.keys() ) )}. ''' F'''Select the correct one and provide it as `field=\'XXX\'` to the dataset loading method. ''' ) from None # Uncomment for debugging (will print the Arrow table size and elements) # logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}") # logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows))) yield (file_idx, batch_idx), self._cast_table(__snake_case ) batch_idx += 1

from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available _SCREAMING_SNAKE_CASE : int = { "configuration_timesformer": ["TIMESFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP", "TimesformerConfig"], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _SCREAMING_SNAKE_CASE : Dict = [ "TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST", "TimesformerModel", "TimesformerForVideoClassification", "TimesformerPreTrainedModel", ] if TYPE_CHECKING: from .configuration_timesformer import TIMESFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, TimesformerConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_timesformer import ( TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, TimesformerForVideoClassification, TimesformerModel, TimesformerPreTrainedModel, ) else: import sys _SCREAMING_SNAKE_CASE : int = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)

"""simple docstring""" import fire from transformers import AutoConfig, AutoModelForSeqaSeqLM, AutoTokenizer def _snake_case ( lowerCamelCase__ : str , lowerCamelCase__ : str , **lowerCamelCase__ : Optional[Any] ) -> str: lowerCamelCase_ : int =AutoConfig.from_pretrained(lowerCamelCase__ , **lowerCamelCase__ ) lowerCamelCase_ : List[Any] =AutoModelForSeqaSeqLM.from_config(lowerCamelCase__ ) model.save_pretrained(lowerCamelCase__ ) AutoTokenizer.from_pretrained(lowerCamelCase__ ).save_pretrained(lowerCamelCase__ ) return model if __name__ == "__main__": fire.Fire(save_randomly_initialized_version)

"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_tokenizers_available, is_torch_available, ) A__ : Tuple = {'configuration_reformer': ['REFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ReformerConfig']} try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: A__ : str = ['ReformerTokenizer'] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: A__ : Any = ['ReformerTokenizerFast'] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: A__ : Dict = [ 'REFORMER_PRETRAINED_MODEL_ARCHIVE_LIST', 'ReformerAttention', 'ReformerForMaskedLM', 'ReformerForQuestionAnswering', 'ReformerForSequenceClassification', 'ReformerLayer', 'ReformerModel', 'ReformerModelWithLMHead', 'ReformerPreTrainedModel', ] if TYPE_CHECKING: from .configuration_reformer import REFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, ReformerConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_reformer import ReformerTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_reformer_fast import ReformerTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_reformer import ( REFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, ReformerAttention, ReformerForMaskedLM, ReformerForQuestionAnswering, ReformerForSequenceClassification, ReformerLayer, ReformerModel, ReformerModelWithLMHead, ReformerPreTrainedModel, ) else: import sys A__ : Any = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

'''simple docstring''' def __lowerCamelCase ( _lowercase ) -> bool: return sum(i for i in range(1 , number // 2 + 1 ) if number % i == 0 ) == number if __name__ == "__main__": print("""Program to check whether a number is a Perfect number or not...""") a : Optional[Any] = int(input("""Enter number: """).strip()) print(F'''{number} is {'' if perfect(number) else 'not '}a Perfect Number.''')

'''simple docstring''' a : Dict = """ABCDEFGHIJKLMNOPQRSTUVWXYZ""" def __lowerCamelCase ( ) -> None: UpperCAmelCase : Optional[int] = input("""Enter message: """ ) UpperCAmelCase : Dict = input("""Enter key [alphanumeric]: """ ) UpperCAmelCase : Optional[Any] = input("""Encrypt/Decrypt [e/d]: """ ) if mode.lower().startswith("""e""" ): UpperCAmelCase : List[str] = """encrypt""" UpperCAmelCase : List[str] = encrypt_message(_lowercase , _lowercase ) elif mode.lower().startswith("""d""" ): UpperCAmelCase : Tuple = """decrypt""" UpperCAmelCase : str = decrypt_message(_lowercase , _lowercase ) print(F'''\n{mode.title()}ed message:''' ) print(_lowercase ) def __lowerCamelCase ( _lowercase , _lowercase ) -> str: return translate_message(_lowercase , _lowercase , """encrypt""" ) def __lowerCamelCase ( _lowercase , _lowercase ) -> str: return translate_message(_lowercase , _lowercase , """decrypt""" ) def __lowerCamelCase ( _lowercase , _lowercase , _lowercase ) -> str: UpperCAmelCase : Optional[int] = [] UpperCAmelCase : Optional[Any] = 0 UpperCAmelCase : Tuple = key.upper() for symbol in message: UpperCAmelCase : Dict = LETTERS.find(symbol.upper() ) if num != -1: if mode == "encrypt": num += LETTERS.find(key[key_index] ) elif mode == "decrypt": num -= LETTERS.find(key[key_index] ) num %= len(_lowercase ) if symbol.isupper(): translated.append(LETTERS[num] ) elif symbol.islower(): translated.append(LETTERS[num].lower() ) key_index += 1 if key_index == len(_lowercase ): UpperCAmelCase : Optional[int] = 0 else: translated.append(_lowercase ) return "".join(_lowercase ) if __name__ == "__main__": main()

"""simple docstring""" import numpy # List of input, output pairs UpperCamelCase : Dict = ( ((5, 2, 3), 1_5), ((6, 5, 9), 2_5), ((1_1, 1_2, 1_3), 4_1), ((1, 1, 1), 8), ((1_1, 1_2, 1_3), 4_1), ) UpperCamelCase : List[Any] = (((5_1_5, 2_2, 1_3), 5_5_5), ((6_1, 3_5, 4_9), 1_5_0)) UpperCamelCase : Dict = [2, 4, 1, 5] UpperCamelCase : Union[str, Any] = len(train_data) UpperCamelCase : Dict = 0.0_09 def A ( snake_case :Any , snake_case :Tuple="train" ) -> str: return calculate_hypothesis_value(snake_case , snake_case ) - output( snake_case , snake_case ) def A ( snake_case :Union[str, Any] ) -> str: __UpperCamelCase = 0 for i in range(len(snake_case ) - 1 ): hyp_val += data_input_tuple[i] * parameter_vector[i + 1] hyp_val += parameter_vector[0] return hyp_val def A ( snake_case :List[str] , snake_case :List[Any] ) -> Union[str, Any]: if data_set == "train": return train_data[example_no][1] elif data_set == "test": return test_data[example_no][1] return None def A ( snake_case :List[Any] , snake_case :Optional[int] ) -> Union[str, Any]: if data_set == "train": return _hypothesis_value(train_data[example_no][0] ) elif data_set == "test": return _hypothesis_value(test_data[example_no][0] ) return None def A ( snake_case :List[str] , snake_case :Dict=m ) -> Dict: __UpperCamelCase = 0 for i in range(snake_case ): if index == -1: summation_value += _error(snake_case ) else: summation_value += _error(snake_case ) * train_data[i][0][index] return summation_value def A ( snake_case :int ) -> Dict: __UpperCamelCase = summation_of_cost_derivative(snake_case , snake_case ) / m return cost_derivative_value def A ( ) -> List[str]: global parameter_vector # Tune these values to set a tolerance value for predicted output __UpperCamelCase = 0.000_002 __UpperCamelCase = 0 __UpperCamelCase = 0 while True: j += 1 __UpperCamelCase = [0, 0, 0, 0] for i in range(0 , len(snake_case ) ): __UpperCamelCase = get_cost_derivative(i - 1 ) __UpperCamelCase = ( parameter_vector[i] - LEARNING_RATE * cost_derivative ) if numpy.allclose( snake_case , snake_case , atol=snake_case , rtol=snake_case , ): break __UpperCamelCase = temp_parameter_vector print(('Number of iterations:', j) ) def A ( ) -> Any: for i in range(len(snake_case ) ): print(('Actual output value:', output(snake_case , 'test' )) ) print(('Hypothesis output:', calculate_hypothesis_value(snake_case , 'test' )) ) if __name__ == "__main__": run_gradient_descent() print("\nTesting gradient descent for a linear hypothesis function.\n") test_gradient_descent()

"""simple docstring""" def A ( snake_case :int ) -> list: # bit count represents no. of bits in the gray code if bit_count < 0: raise ValueError('The given input must be positive' ) # get the generated string sequence __UpperCamelCase = gray_code_sequence_string(snake_case ) # # convert them to integers for i in range(len(snake_case ) ): __UpperCamelCase = int(sequence[i] , 2 ) return sequence def A ( snake_case :int ) -> list: # The approach is a recursive one # Base case achieved when either n = 0 or n=1 if bit_count == 0: return ["0"] if bit_count == 1: return ["0", "1"] __UpperCamelCase = 1 << bit_count # defines the length of the sequence # 1<< n is equivalent to 2^n # recursive answer will generate answer for n-1 bits __UpperCamelCase = gray_code_sequence_string(bit_count - 1 ) __UpperCamelCase = [] # append 0 to first half of the smaller sequence generated for i in range(seq_len // 2 ): __UpperCamelCase = '0' + smaller_sequence[i] sequence.append(snake_case ) # append 1 to second half ... start from the end of the list for i in reversed(range(seq_len // 2 ) ): __UpperCamelCase = '1' + smaller_sequence[i] sequence.append(snake_case ) return sequence if __name__ == "__main__": import doctest doctest.testmod()

import functools import operator from ...configuration_utils import PretrainedConfig from ...utils import logging lowercase : Optional[Any] = logging.get_logger(__name__) lowercase : Optional[Any] = { 'microsoft/wavlm-base': 'https://huggingface.co/microsoft/wavlm-base/resolve/main/config.json', # See all WavLM models at https://huggingface.co/models?filter=wavlm } class __snake_case ( lowerCamelCase__ ): _a : int= "wavlm" def __init__( self ,snake_case=32 ,snake_case=768 ,snake_case=12 ,snake_case=12 ,snake_case=3072 ,snake_case="gelu" ,snake_case=0.1 ,snake_case=0.1 ,snake_case=0.1 ,snake_case=0.0 ,snake_case=0.1 ,snake_case=0.1 ,snake_case=0.02 ,snake_case=1e-5 ,snake_case="group" ,snake_case="gelu" ,snake_case=(512, 512, 512, 512, 512, 512, 512) ,snake_case=(5, 2, 2, 2, 2, 2, 2) ,snake_case=(10, 3, 3, 3, 3, 2, 2) ,snake_case=False ,snake_case=128 ,snake_case=16 ,snake_case=320 ,snake_case=800 ,snake_case=False ,snake_case=True ,snake_case=0.05 ,snake_case=10 ,snake_case=2 ,snake_case=0.0 ,snake_case=10 ,snake_case=320 ,snake_case=2 ,snake_case=0.1 ,snake_case=100 ,snake_case=256 ,snake_case=256 ,snake_case=0.1 ,snake_case="mean" ,snake_case=False ,snake_case=False ,snake_case=256 ,snake_case=(512, 512, 512, 512, 1500) ,snake_case=(5, 3, 3, 1, 1) ,snake_case=(1, 2, 3, 1, 1) ,snake_case=512 ,snake_case=80 ,snake_case=0 ,snake_case=1 ,snake_case=2 ,snake_case=False ,snake_case=3 ,snake_case=2 ,snake_case=3 ,snake_case=None ,**snake_case ,): '''simple docstring''' super().__init__(**__lowerCamelCase ,pad_token_id=__lowerCamelCase ,bos_token_id=__lowerCamelCase ,eos_token_id=__lowerCamelCase ) lowercase : Union[str, Any] = hidden_size lowercase : List[Any] = feat_extract_norm lowercase : Optional[int] = feat_extract_activation lowercase : Any = list(__lowerCamelCase ) lowercase : Tuple = list(__lowerCamelCase ) lowercase : List[Any] = list(__lowerCamelCase ) lowercase : str = conv_bias lowercase : List[str] = num_buckets lowercase : str = max_bucket_distance lowercase : str = num_conv_pos_embeddings lowercase : Dict = num_conv_pos_embedding_groups lowercase : Optional[Any] = len(self.conv_dim ) lowercase : Optional[Any] = num_hidden_layers lowercase : Optional[Any] = intermediate_size lowercase : Dict = hidden_act lowercase : int = num_attention_heads lowercase : Optional[int] = hidden_dropout lowercase : Optional[Any] = attention_dropout lowercase : Optional[int] = activation_dropout lowercase : str = feat_proj_dropout lowercase : List[str] = final_dropout lowercase : Union[str, Any] = layerdrop lowercase : Dict = layer_norm_eps lowercase : Tuple = initializer_range lowercase : int = num_ctc_classes lowercase : List[Any] = vocab_size lowercase : str = do_stable_layer_norm lowercase : Dict = use_weighted_layer_sum lowercase : int = classifier_proj_size if ( (len(self.conv_stride ) != self.num_feat_extract_layers) or (len(self.conv_kernel ) != self.num_feat_extract_layers) or (len(self.conv_dim ) != self.num_feat_extract_layers) ): raise ValueError( """Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` ==""" """ `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) =""" f" {len(self.conv_dim )}`, `len(config.conv_stride) = {len(self.conv_stride )}`," f" `len(config.conv_kernel) = {len(self.conv_kernel )}`." ) # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779 lowercase : Any = apply_spec_augment lowercase : List[str] = mask_time_prob lowercase : Tuple = mask_time_length lowercase : int = mask_time_min_masks lowercase : Any = mask_feature_prob lowercase : Union[str, Any] = mask_feature_length # parameters for pretraining with codevector quantized representations lowercase : str = num_codevectors_per_group lowercase : Optional[Any] = num_codevector_groups lowercase : Tuple = contrastive_logits_temperature lowercase : List[Any] = num_negatives lowercase : List[Any] = codevector_dim lowercase : Dict = proj_codevector_dim lowercase : Any = diversity_loss_weight # ctc loss lowercase : Optional[int] = ctc_loss_reduction lowercase : int = ctc_zero_infinity # adapter lowercase : int = add_adapter lowercase : Optional[int] = adapter_kernel_size lowercase : Tuple = adapter_stride lowercase : Optional[Any] = num_adapter_layers lowercase : int = output_hidden_size or hidden_size # SequenceClassification-specific parameter. Feel free to ignore for other classes. lowercase : Optional[int] = classifier_proj_size # XVector-specific parameters. Feel free to ignore for other classes. lowercase : str = list(__lowerCamelCase ) lowercase : List[Any] = list(__lowerCamelCase ) lowercase : List[str] = list(__lowerCamelCase ) lowercase : Optional[Any] = xvector_output_dim @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return functools.reduce(operator.mul ,self.conv_stride ,1 )

print((lambda quine: quine % quine)("""print((lambda quine: quine %% quine)(%r))"""))

"""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 lowerCAmelCase__ ( UpperCamelCase__ ): '''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 UpperCamelCase ( nn.Module ): def __init__( self : Union[str, Any] , UpperCAmelCase__ : nn.Module , UpperCAmelCase__ : int ) -> str: super().__init__() _a : Dict = module _a : Optional[int] = nn.Sequential( nn.Linear(module.in_features , UpperCAmelCase__ , bias=UpperCAmelCase__ ) , nn.Linear(UpperCAmelCase__ , module.out_features , bias=UpperCAmelCase__ ) , ) _a : Union[str, Any] = (2.0 / (5 * min(module.in_features , module.out_features ))) ** 0.5 nn.init.normal_(self.adapter[0].weight , std=UpperCAmelCase__ ) nn.init.zeros_(self.adapter[1].weight ) self.adapter.to(module.weight.device ) def _lowercase ( self : Tuple , UpperCAmelCase__ : Tuple , *UpperCAmelCase__ : Union[str, Any] , **UpperCAmelCase__ : Optional[Any] ) -> Optional[int]: return self.module(UpperCAmelCase__ , *UpperCAmelCase__ , **UpperCAmelCase__ ) + self.adapter(UpperCAmelCase__ ) @require_bitsandbytes @require_accelerate @require_torch @require_torch_gpu @slow class UpperCamelCase ( unittest.TestCase ): # We keep the constants inside the init function and model loading inside setUp function # We need to test on relatively large models (aka >1b parameters otherwise the quantiztion may not work as expected) # Therefore here we use only bloom-1b3 to test our module UpperCamelCase : Optional[Any] = '''bigscience/bloom-1b7''' # Constant values UpperCamelCase : List[str] = 2.1_0_9_6_5_9_5_5_2_6_9_2_5_7_4 UpperCamelCase : int = '''Hello my name is''' UpperCamelCase : Dict = 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 : Optional[Any] = 10 def _lowercase ( self : Union[str, Any] ) -> List[str]: # Models and tokenizer _a : Dict = AutoTokenizer.from_pretrained(self.model_name ) class UpperCamelCase ( snake_case_ ): def _lowercase ( self : int ) -> Optional[Any]: super().setUp() # Models and tokenizer _a : Optional[int] = AutoModelForCausalLM.from_pretrained( self.model_name , torch_dtype=torch.floataa , device_map="""auto""" ) _a : Optional[int] = AutoModelForCausalLM.from_pretrained(self.model_name , load_in_abit=UpperCAmelCase__ , device_map="""auto""" ) def _lowercase ( self : Any ) -> Optional[Any]: del self.model_fpaa del self.model_abit gc.collect() torch.cuda.empty_cache() def _lowercase ( self : List[str] ) -> Union[str, Any]: _a : Dict = self.model_abit.config self.assertTrue(hasattr(UpperCAmelCase__ , """quantization_config""" ) ) _a : Optional[Any] = config.to_dict() _a : List[str] = config.to_diff_dict() _a : Tuple = config.to_json_string() def _lowercase ( self : Dict ) -> List[str]: from bitsandbytes.nn import Paramsabit _a : Optional[Any] = self.model_fpaa.get_memory_footprint() _a : Optional[int] = self.model_abit.get_memory_footprint() self.assertAlmostEqual(mem_fpaa / mem_abit , self.EXPECTED_RELATIVE_DIFFERENCE ) _a : Optional[Any] = get_some_linear_layer(self.model_abit ) self.assertTrue(linear.weight.__class__ == Paramsabit ) def _lowercase ( self : Union[str, Any] ) -> List[Any]: 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(UpperCAmelCase__ , 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 _lowercase ( self : Union[str, Any] ) -> List[str]: _a : Optional[int] = self.tokenizer(self.input_text , return_tensors="""pt""" ) _a : Optional[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=UpperCAmelCase__ ) , self.EXPECTED_OUTPUTS ) def _lowercase ( self : Optional[int] ) -> str: _a : str = BitsAndBytesConfig() _a : Any = True _a : int = AutoModelForCausalLM.from_pretrained( self.model_name , quantization_config=UpperCAmelCase__ , device_map="""auto""" ) _a : Optional[Any] = self.tokenizer(self.input_text , return_tensors="""pt""" ) _a : Union[str, Any] = 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=UpperCAmelCase__ ) , self.EXPECTED_OUTPUTS ) def _lowercase ( self : List[str] ) -> Tuple: with self.assertRaises(UpperCAmelCase__ ), tempfile.TemporaryDirectory() as tmpdirname: self.model_abit.save_pretrained(UpperCAmelCase__ ) def _lowercase ( self : int ) -> int: _a : Any = BitsAndBytesConfig() with self.assertRaises(UpperCAmelCase__ ): _a : List[Any] = AutoModelForCausalLM.from_pretrained( self.model_name , quantization_config=UpperCAmelCase__ , load_in_abit=UpperCAmelCase__ , device_map="""auto""" , bnb_abit_quant_type="""nf4""" , ) def _lowercase ( self : Dict ) -> Any: with self.assertRaises(UpperCAmelCase__ ): # Tries with `str` self.model_abit.to("""cpu""" ) with self.assertRaises(UpperCAmelCase__ ): # Tries with a `dtype`` self.model_abit.to(torch.floataa ) with self.assertRaises(UpperCAmelCase__ ): # Tries with a `device` self.model_abit.to(torch.device("""cuda:0""" ) ) with self.assertRaises(UpperCAmelCase__ ): # Tries with a `device` self.model_abit.float() with self.assertRaises(UpperCAmelCase__ ): # Tries with a `device` self.model_abit.half() # Test if we did not break anything _a : Optional[int] = self.tokenizer(self.input_text , return_tensors="""pt""" ) _a : Any = self.model_fpaa.to(torch.floataa ) _a : 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 _a : int = self.model_fpaa.to("""cpu""" ) # Check this does not throw an error _a : Optional[int] = self.model_fpaa.half() # Check this does not throw an error _a : int = self.model_fpaa.float() def _lowercase ( self : Union[str, Any] ) -> Optional[int]: _a : Optional[Any] = AutoModelForSeqaSeqLM.from_pretrained("""t5-small""" , load_in_abit=UpperCAmelCase__ , 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 UpperCamelCase ( unittest.TestCase ): @classmethod def _lowercase ( cls : Optional[int] ) -> Any: _a : Any = """t5-small""" _a : Any = """google/flan-t5-small""" # flan-t5 uses dense-act instead of dense-relu-dense _a : str = AutoTokenizer.from_pretrained(cls.model_name ) _a : Tuple = """Translate in German: Hello, my dog is cute""" def _lowercase ( self : List[Any] ) -> Optional[int]: gc.collect() torch.cuda.empty_cache() def _lowercase ( self : List[str] ) -> Optional[int]: from transformers import TaForConditionalGeneration _a : List[Any] = TaForConditionalGeneration._keep_in_fpaa_modules _a : Dict = None # test with `t5-small` _a : Union[str, Any] = TaForConditionalGeneration.from_pretrained(self.model_name , load_in_abit=UpperCAmelCase__ , device_map="""auto""" ) _a : List[str] = self.tokenizer(self.input_text , return_tensors="""pt""" ).to(0 ) _a : str = model.generate(**UpperCAmelCase__ ) # test with `flan-t5-small` _a : List[str] = TaForConditionalGeneration.from_pretrained( self.dense_act_model_name , load_in_abit=UpperCAmelCase__ , device_map="""auto""" ) _a : str = self.tokenizer(self.input_text , return_tensors="""pt""" ).to(0 ) _a : int = model.generate(**UpperCAmelCase__ ) _a : Dict = modules def _lowercase ( self : Any ) -> Optional[Any]: import bitsandbytes as bnb from transformers import TaForConditionalGeneration # test with `t5-small` _a : List[Any] = TaForConditionalGeneration.from_pretrained(self.model_name , load_in_abit=UpperCAmelCase__ , 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 ) ) _a : str = self.tokenizer(self.input_text , return_tensors="""pt""" ).to(0 ) _a : List[str] = model.generate(**UpperCAmelCase__ ) # test with `flan-t5-small` _a : str = TaForConditionalGeneration.from_pretrained( self.dense_act_model_name , load_in_abit=UpperCAmelCase__ , device_map="""auto""" ) _a : str = self.tokenizer(self.input_text , return_tensors="""pt""" ).to(0 ) _a : Optional[int] = model.generate(**UpperCAmelCase__ ) class UpperCamelCase ( snake_case_ ): def _lowercase ( self : Optional[int] ) -> str: super().setUp() # model_name _a : str = """bigscience/bloom-560m""" _a : str = """t5-small""" # Different types of model _a : Optional[Any] = AutoModel.from_pretrained(self.model_name , load_in_abit=UpperCAmelCase__ , device_map="""auto""" ) # Sequence classification model _a : List[str] = AutoModelForSequenceClassification.from_pretrained( self.model_name , load_in_abit=UpperCAmelCase__ , device_map="""auto""" ) # CausalLM model _a : Optional[Any] = AutoModelForCausalLM.from_pretrained(self.model_name , load_in_abit=UpperCAmelCase__ , device_map="""auto""" ) # Seq2seq model _a : Optional[int] = AutoModelForSeqaSeqLM.from_pretrained( self.seq_to_seq_name , load_in_abit=UpperCAmelCase__ , device_map="""auto""" ) def _lowercase ( self : Union[str, Any] ) -> int: 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 _lowercase ( self : int ) -> Tuple: 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 UpperCamelCase ( snake_case_ ): def _lowercase ( self : Dict ) -> Optional[int]: super().setUp() def _lowercase ( self : List[Any] ) -> Dict: del self.pipe gc.collect() torch.cuda.empty_cache() def _lowercase ( self : int ) -> List[str]: _a : Union[str, Any] = 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 _a : Dict = self.pipe(self.input_text ) self.assertIn(pipeline_output[0]["""generated_text"""] , self.EXPECTED_OUTPUTS ) @require_torch_multi_gpu class UpperCamelCase ( snake_case_ ): def _lowercase ( self : int ) -> Tuple: super().setUp() def _lowercase ( self : List[str] ) -> Union[str, Any]: _a : List[Any] = AutoModelForCausalLM.from_pretrained( self.model_name , load_in_abit=UpperCAmelCase__ , 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 _a : Union[str, Any] = self.tokenizer(self.input_text , return_tensors="""pt""" ) # Second real batch _a : List[str] = 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=UpperCAmelCase__ ) , self.EXPECTED_OUTPUTS ) class UpperCamelCase ( snake_case_ ): def _lowercase ( self : Tuple ) -> Tuple: _a : Any = """facebook/opt-350m""" super().setUp() def _lowercase ( self : Tuple ) -> str: if version.parse(importlib.metadata.version("""bitsandbytes""" ) ) < version.parse("""0.37.0""" ): return # Step 1: freeze all parameters _a : Optional[Any] = AutoModelForCausalLM.from_pretrained(self.model_name , load_in_abit=UpperCAmelCase__ ) self.assertEqual(set(model.hf_device_map.values() ) , {torch.cuda.current_device()} ) for param in model.parameters(): _a : Optional[int] = False # freeze the model - train adapters later if param.ndim == 1: # cast the small parameters (e.g. layernorm) to fp32 for stability _a : Tuple = param.data.to(torch.floataa ) # Step 2: add adapters for _, module in model.named_modules(): if "OPTAttention" in repr(type(UpperCAmelCase__ ) ): _a : Union[str, Any] = LoRALayer(module.q_proj , rank=16 ) _a : List[str] = LoRALayer(module.k_proj , rank=16 ) _a : Dict = LoRALayer(module.v_proj , rank=16 ) # Step 3: dummy batch _a : Union[str, Any] = self.tokenizer("""Test batch """ , return_tensors="""pt""" ).to(0 ) # Step 4: Check if the gradient is not None with torch.cuda.amp.autocast(): _a : Optional[Any] = model.forward(**UpperCAmelCase__ ) out.logits.norm().backward() for module in model.modules(): if isinstance(UpperCAmelCase__ , UpperCAmelCase__ ): self.assertTrue(module.adapter[1].weight.grad is not None ) self.assertTrue(module.adapter[1].weight.grad.norm().item() > 0 ) elif isinstance(UpperCAmelCase__ , nn.Embedding ): self.assertTrue(module.weight.grad is None ) class UpperCamelCase ( snake_case_ ): UpperCamelCase : Optional[int] = '''gpt2-xl''' UpperCamelCase : Union[str, Any] = 3.3_1_9_1_8_5_4_8_5_4_1_5_2_1_8_7

"""simple docstring""" from __future__ import annotations def lowerCAmelCase__ ( UpperCamelCase__ , UpperCamelCase__ ): '''simple docstring''' print(F"""Vertex\tShortest Distance from vertex {src}""" ) for i, d in enumerate(UpperCamelCase__ ): print(F"""{i}\t\t{d}""" ) def lowerCAmelCase__ ( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ): '''simple docstring''' for j in range(UpperCamelCase__ ): _a , _a , _a : List[str] = (graph[j][k] for k in ["""src""", """dst""", """weight"""]) if distance[u] != float("""inf""" ) and distance[u] + w < distance[v]: return True return False def lowerCAmelCase__ ( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ): '''simple docstring''' _a : Dict = [float("""inf""" )] * vertex_count _a : Any = 0.0 for _ in range(vertex_count - 1 ): for j in range(UpperCamelCase__ ): _a , _a , _a : List[Any] = (graph[j][k] for k in ["""src""", """dst""", """weight"""]) if distance[u] != float("""inf""" ) and distance[u] + w < distance[v]: _a : Any = distance[u] + w _a : Union[str, Any] = check_negative_cycle(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) if negative_cycle_exists: raise Exception("""Negative cycle found""" ) return distance if __name__ == "__main__": import doctest doctest.testmod() _snake_case = int(input('Enter number of vertices: ').strip()) _snake_case = int(input('Enter number of edges: ').strip()) _snake_case = [{} for _ in range(E)] for i in range(E): print('Edge ', i + 1) _snake_case , _snake_case , _snake_case = ( int(x) for x in input('Enter source, destination, weight: ').strip().split(' ') ) _snake_case = {'src': src, 'dst': dest, 'weight': weight} _snake_case = int(input('\nEnter shortest path source:').strip()) _snake_case = bellman_ford(graph, V, E, source) print_distance(shortest_distance, 0)

from typing import Optional, Union import torch from torch import nn from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss from ...activations import ACTaFN from ...modeling_outputs import BaseModelOutputWithPoolingAndNoAttention, ImageClassifierOutputWithNoAttention from ...modeling_utils import PreTrainedModel from ...utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, logging from .configuration_mobilenet_va import MobileNetVaConfig UpperCAmelCase : Optional[Any] = logging.get_logger(__name__) # General docstring UpperCAmelCase : Optional[int] = """MobileNetV1Config""" # Base docstring UpperCAmelCase : List[Any] = """google/mobilenet_v1_1.0_224""" UpperCAmelCase : List[str] = [1, 1024, 7, 7] # Image classification docstring UpperCAmelCase : Any = """google/mobilenet_v1_1.0_224""" UpperCAmelCase : List[Any] = """tabby, tabby cat""" UpperCAmelCase : List[str] = [ """google/mobilenet_v1_1.0_224""", """google/mobilenet_v1_0.75_192""", # See all MobileNetV1 models at https://huggingface.co/models?filter=mobilenet_v1 ] def _A ( SCREAMING_SNAKE_CASE : str , SCREAMING_SNAKE_CASE : Optional[int] , SCREAMING_SNAKE_CASE : Union[str, Any]=None ): """simple docstring""" a__ : Dict ={} if isinstance(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE ): a__ : str =model.mobilenet_va else: a__ : int =model a__ : Optional[int] ="MobilenetV1/Conv2d_0/" a__ : str =backbone.conv_stem.convolution.weight a__ : List[Any] =backbone.conv_stem.normalization.bias a__ : Union[str, Any] =backbone.conv_stem.normalization.weight a__ : int =backbone.conv_stem.normalization.running_mean a__ : Any =backbone.conv_stem.normalization.running_var for i in range(13 ): a__ : int =i + 1 a__ : int =i * 2 a__ : Union[str, Any] =backbone.layer[pt_index] a__ : Union[str, Any] =f'''MobilenetV1/Conv2d_{tf_index}_depthwise/''' a__ : Union[str, Any] =pointer.convolution.weight a__ : Optional[Any] =pointer.normalization.bias a__ : str =pointer.normalization.weight a__ : str =pointer.normalization.running_mean a__ : str =pointer.normalization.running_var a__ : List[Any] =backbone.layer[pt_index + 1] a__ : str =f'''MobilenetV1/Conv2d_{tf_index}_pointwise/''' a__ : Any =pointer.convolution.weight a__ : Optional[Any] =pointer.normalization.bias a__ : Tuple =pointer.normalization.weight a__ : List[Any] =pointer.normalization.running_mean a__ : List[Any] =pointer.normalization.running_var if isinstance(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE ): a__ : List[str] ="MobilenetV1/Logits/Conv2d_1c_1x1/" a__ : str =model.classifier.weight a__ : List[Any] =model.classifier.bias return tf_to_pt_map def _A ( SCREAMING_SNAKE_CASE : List[Any] , SCREAMING_SNAKE_CASE : str , SCREAMING_SNAKE_CASE : List[str] ): """simple docstring""" try: import numpy as np import tensorflow as tf except ImportError: logger.error( "Loading a TensorFlow models in PyTorch, requires TensorFlow to be installed. Please see " "https://www.tensorflow.org/install/ for installation instructions." ) raise # Load weights from TF model a__ : Tuple =tf.train.list_variables(SCREAMING_SNAKE_CASE ) a__ : Optional[Any] ={} for name, shape in init_vars: logger.info(f'''Loading TF weight {name} with shape {shape}''' ) a__ : List[Any] =tf.train.load_variable(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE ) a__ : Tuple =array # Build TF to PyTorch weights loading map a__ : Optional[Any] =_build_tf_to_pytorch_map(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE ) for name, pointer in tf_to_pt_map.items(): logger.info(f'''Importing {name}''' ) if name not in tf_weights: logger.info(f'''{name} not in tf pre-trained weights, skipping''' ) continue a__ : Optional[int] =tf_weights[name] if "depthwise_weights" in name: logger.info("Transposing depthwise" ) a__ : List[str] =np.transpose(SCREAMING_SNAKE_CASE , (2, 3, 0, 1) ) elif "weights" in name: logger.info("Transposing" ) if len(pointer.shape ) == 2: # copying into linear layer a__ : Optional[Any] =array.squeeze().transpose() else: a__ : Union[str, Any] =np.transpose(SCREAMING_SNAKE_CASE , (3, 2, 0, 1) ) if pointer.shape != array.shape: raise ValueError(f'''Pointer shape {pointer.shape} and array shape {array.shape} mismatched''' ) logger.info(f'''Initialize PyTorch weight {name} {array.shape}''' ) a__ : List[str] =torch.from_numpy(SCREAMING_SNAKE_CASE ) tf_weights.pop(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE ) tf_weights.pop(name + "/RMSProp" , SCREAMING_SNAKE_CASE ) tf_weights.pop(name + "/RMSProp_1" , SCREAMING_SNAKE_CASE ) tf_weights.pop(name + "/ExponentialMovingAverage" , SCREAMING_SNAKE_CASE ) logger.info(f'''Weights not copied to PyTorch model: {", ".join(tf_weights.keys() )}''' ) return model def _A ( SCREAMING_SNAKE_CASE : torch.Tensor , SCREAMING_SNAKE_CASE : nn.Convad ): """simple docstring""" a__ : Optional[int] =features.shape[-2:] a__ : List[str] =conv_layer.stride a__ : List[str] =conv_layer.kernel_size if in_height % stride_height == 0: a__ : Dict =max(kernel_height - stride_height , 0 ) else: a__ : Dict =max(kernel_height - (in_height % stride_height) , 0 ) if in_width % stride_width == 0: a__ : Dict =max(kernel_width - stride_width , 0 ) else: a__ : int =max(kernel_width - (in_width % stride_width) , 0 ) a__ : List[Any] =pad_along_width // 2 a__ : Optional[int] =pad_along_width - pad_left a__ : Tuple =pad_along_height // 2 a__ : Dict =pad_along_height - pad_top a__ : List[str] =(pad_left, pad_right, pad_top, pad_bottom) return nn.functional.pad(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , "constant" , 0.0 ) class __lowerCAmelCase ( nn.Module): def __init__( self , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ = 1 , lowerCAmelCase__ = 1 , lowerCAmelCase__ = False , lowerCAmelCase__ = True , lowerCAmelCase__ = True , ) -> None: '''simple docstring''' super().__init__() a__ : Union[str, Any] =config if in_channels % groups != 0: raise ValueError(F'''Input channels ({in_channels}) are not divisible by {groups} groups.''' ) if out_channels % groups != 0: raise ValueError(F'''Output channels ({out_channels}) are not divisible by {groups} groups.''' ) a__ : Dict =0 if config.tf_padding else int((kernel_size - 1) / 2 ) a__ : List[Any] =nn.Convad( in_channels=lowerCAmelCase__ , out_channels=lowerCAmelCase__ , kernel_size=lowerCAmelCase__ , stride=lowerCAmelCase__ , padding=lowerCAmelCase__ , groups=lowerCAmelCase__ , bias=lowerCAmelCase__ , padding_mode="zeros" , ) if use_normalization: a__ : str =nn.BatchNormad( num_features=lowerCAmelCase__ , eps=config.layer_norm_eps , momentum=0.99_97 , affine=lowerCAmelCase__ , track_running_stats=lowerCAmelCase__ , ) else: a__ : Optional[int] =None if use_activation: if isinstance(lowerCAmelCase__ , lowerCAmelCase__ ): a__ : Optional[int] =ACTaFN[use_activation] elif isinstance(config.hidden_act , lowerCAmelCase__ ): a__ : Optional[Any] =ACTaFN[config.hidden_act] else: a__ : List[str] =config.hidden_act else: a__ : List[str] =None def _lowercase ( self , lowerCAmelCase__ ) -> torch.Tensor: '''simple docstring''' if self.config.tf_padding: a__ : Optional[int] =apply_tf_padding(lowerCAmelCase__ , self.convolution ) a__ : Tuple =self.convolution(lowerCAmelCase__ ) if self.normalization is not None: a__ : Dict =self.normalization(lowerCAmelCase__ ) if self.activation is not None: a__ : int =self.activation(lowerCAmelCase__ ) return features class __lowerCAmelCase ( UpperCamelCase__): _lowercase : Optional[int] = MobileNetVaConfig _lowercase : Optional[int] = load_tf_weights_in_mobilenet_va _lowercase : str = """mobilenet_v1""" _lowercase : str = """pixel_values""" _lowercase : Dict = False def _lowercase ( self , lowerCAmelCase__ ) -> None: '''simple docstring''' if isinstance(lowerCAmelCase__ , (nn.Linear, nn.Convad) ): module.weight.data.normal_(mean=0.0 , std=self.config.initializer_range ) if module.bias is not None: module.bias.data.zero_() elif isinstance(lowerCAmelCase__ , nn.BatchNormad ): module.bias.data.zero_() module.weight.data.fill_(1.0 ) UpperCAmelCase : Union[str, Any] = r""" This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and behavior. Parameters: config ([`MobileNetV1Config`]): Model configuration class with all the parameters of the model. Initializing with a config file does not load the weights associated with the model, only the configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights. """ UpperCAmelCase : List[str] = r""" Args: pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`): Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See [`MobileNetV1ImageProcessor.__call__`] for details. output_hidden_states (`bool`, *optional*): Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for more detail. return_dict (`bool`, *optional*): Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple. """ @add_start_docstrings( """The bare MobileNetV1 model outputting raw hidden-states without any specific head on top.""" , UpperCamelCase__ , ) class __lowerCAmelCase ( UpperCamelCase__): def __init__( self , lowerCAmelCase__ , lowerCAmelCase__ = True ) -> str: '''simple docstring''' super().__init__(lowerCAmelCase__ ) a__ : Tuple =config a__ : Dict =3_2 a__ : Union[str, Any] =max(int(depth * config.depth_multiplier ) , config.min_depth ) a__ : Union[str, Any] =MobileNetVaConvLayer( lowerCAmelCase__ , in_channels=config.num_channels , out_channels=lowerCAmelCase__ , kernel_size=3 , stride=2 , ) a__ : Dict =[1, 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 2, 1] a__ : Tuple =nn.ModuleList() for i in range(1_3 ): a__ : Optional[int] =out_channels if strides[i] == 2 or i == 0: depth *= 2 a__ : Tuple =max(int(depth * config.depth_multiplier ) , config.min_depth ) self.layer.append( MobileNetVaConvLayer( lowerCAmelCase__ , in_channels=lowerCAmelCase__ , out_channels=lowerCAmelCase__ , kernel_size=3 , stride=strides[i] , groups=lowerCAmelCase__ , ) ) self.layer.append( MobileNetVaConvLayer( lowerCAmelCase__ , in_channels=lowerCAmelCase__ , out_channels=lowerCAmelCase__ , kernel_size=1 , ) ) a__ : str =nn.AdaptiveAvgPoolad((1, 1) ) if add_pooling_layer else None # Initialize weights and apply final processing self.post_init() def _lowercase ( self , lowerCAmelCase__ ) -> List[str]: '''simple docstring''' raise NotImplementedError @add_start_docstrings_to_model_forward(lowerCAmelCase__ ) @add_code_sample_docstrings( checkpoint=_CHECKPOINT_FOR_DOC , output_type=lowerCAmelCase__ , config_class=_CONFIG_FOR_DOC , modality="vision" , expected_output=_EXPECTED_OUTPUT_SHAPE , ) def _lowercase ( self , lowerCAmelCase__ = None , lowerCAmelCase__ = None , lowerCAmelCase__ = None , ) -> Union[tuple, BaseModelOutputWithPoolingAndNoAttention]: '''simple docstring''' a__ : str =( output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states ) a__ : Union[str, Any] =return_dict if return_dict is not None else self.config.use_return_dict if pixel_values is None: raise ValueError("You have to specify pixel_values" ) a__ : Optional[int] =self.conv_stem(lowerCAmelCase__ ) a__ : Dict =() if output_hidden_states else None for i, layer_module in enumerate(self.layer ): a__ : List[str] =layer_module(lowerCAmelCase__ ) if output_hidden_states: a__ : Optional[int] =all_hidden_states + (hidden_states,) a__ : int =hidden_states if self.pooler is not None: a__ : List[str] =torch.flatten(self.pooler(lowerCAmelCase__ ) , start_dim=1 ) else: a__ : Optional[int] =None if not return_dict: return tuple(v for v in [last_hidden_state, pooled_output, all_hidden_states] if v is not None ) return BaseModelOutputWithPoolingAndNoAttention( last_hidden_state=lowerCAmelCase__ , pooler_output=lowerCAmelCase__ , hidden_states=lowerCAmelCase__ , ) @add_start_docstrings( """ MobileNetV1 model with an image classification head on top (a linear layer on top of the pooled features), e.g. for ImageNet. """ , UpperCamelCase__ , ) class __lowerCAmelCase ( UpperCamelCase__): def __init__( self , lowerCAmelCase__ ) -> None: '''simple docstring''' super().__init__(lowerCAmelCase__ ) a__ : List[str] =config.num_labels a__ : Union[str, Any] =MobileNetVaModel(lowerCAmelCase__ ) a__ : Tuple =self.mobilenet_va.layer[-1].convolution.out_channels # Classifier head a__ : Optional[Any] =nn.Dropout(config.classifier_dropout_prob , inplace=lowerCAmelCase__ ) a__ : List[str] =nn.Linear(lowerCAmelCase__ , config.num_labels ) if config.num_labels > 0 else nn.Identity() # Initialize weights and apply final processing self.post_init() @add_start_docstrings_to_model_forward(lowerCAmelCase__ ) @add_code_sample_docstrings( checkpoint=_IMAGE_CLASS_CHECKPOINT , output_type=lowerCAmelCase__ , config_class=_CONFIG_FOR_DOC , expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT , ) def _lowercase ( self , lowerCAmelCase__ = None , lowerCAmelCase__ = None , lowerCAmelCase__ = None , lowerCAmelCase__ = None , ) -> Union[tuple, ImageClassifierOutputWithNoAttention]: '''simple docstring''' a__ : Optional[int] =return_dict if return_dict is not None else self.config.use_return_dict a__ : str =self.mobilenet_va(lowerCAmelCase__ , output_hidden_states=lowerCAmelCase__ , return_dict=lowerCAmelCase__ ) a__ : Any =outputs.pooler_output if return_dict else outputs[1] a__ : int =self.classifier(self.dropout(lowerCAmelCase__ ) ) a__ : Any =None if labels is not None: if self.config.problem_type is None: if self.num_labels == 1: a__ : Dict ="regression" elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int): a__ : int ="single_label_classification" else: a__ : Tuple ="multi_label_classification" if self.config.problem_type == "regression": a__ : List[str] =MSELoss() if self.num_labels == 1: a__ : Tuple =loss_fct(logits.squeeze() , labels.squeeze() ) else: a__ : Dict =loss_fct(lowerCAmelCase__ , lowerCAmelCase__ ) elif self.config.problem_type == "single_label_classification": a__ : str =CrossEntropyLoss() a__ : Optional[Any] =loss_fct(logits.view(-1 , self.num_labels ) , labels.view(-1 ) ) elif self.config.problem_type == "multi_label_classification": a__ : int =BCEWithLogitsLoss() a__ : Optional[int] =loss_fct(lowerCAmelCase__ , lowerCAmelCase__ ) if not return_dict: a__ : Dict =(logits,) + outputs[2:] return ((loss,) + output) if loss is not None else output return ImageClassifierOutputWithNoAttention( loss=lowerCAmelCase__ , logits=lowerCAmelCase__ , hidden_states=outputs.hidden_states , )

import random from typing import Any def _A ( SCREAMING_SNAKE_CASE : list ): """simple docstring""" for _ in range(len(SCREAMING_SNAKE_CASE ) ): a__ : Tuple =random.randint(0 , len(SCREAMING_SNAKE_CASE ) - 1 ) a__ : Any =random.randint(0 , len(SCREAMING_SNAKE_CASE ) - 1 ) a__ , a__ : Tuple =data[b], data[a] return data if __name__ == "__main__": UpperCAmelCase : Dict = [0, 1, 2, 3, 4, 5, 6, 7] UpperCAmelCase : Optional[Any] = ["""python""", """says""", """hello""", """!"""] print("""Fisher-Yates Shuffle:""") print("""List""", integers, strings) print("""FY Shuffle""", fisher_yates_shuffle(integers), fisher_yates_shuffle(strings))

'''simple docstring''' import math from collections.abc import Iterator from itertools import takewhile def __UpperCamelCase ( UpperCAmelCase ): if 1 < number < 4: # 2 and 3 are primes return True elif number < 2 or number % 2 == 0 or number % 3 == 0: # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes return False # All primes number are in format of 6k +/- 1 for i in range(5 , int(math.sqrt(UpperCAmelCase ) + 1 ) , 6 ): if number % i == 0 or number % (i + 2) == 0: return False return True def __UpperCamelCase ( ): lowercase__ : Dict = 2 while True: if is_prime(UpperCAmelCase ): yield num num += 1 def __UpperCamelCase ( UpperCAmelCase = 200_0000 ): return sum(takewhile(lambda UpperCAmelCase : x < n , prime_generator() ) ) if __name__ == "__main__": print(F'{solution() = }')

'''simple docstring''' from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available __a: Dict = { """configuration_ctrl""": ["""CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP""", """CTRLConfig"""], """tokenization_ctrl""": ["""CTRLTokenizer"""], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __a: int = [ """CTRL_PRETRAINED_MODEL_ARCHIVE_LIST""", """CTRLForSequenceClassification""", """CTRLLMHeadModel""", """CTRLModel""", """CTRLPreTrainedModel""", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __a: int = [ """TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST""", """TFCTRLForSequenceClassification""", """TFCTRLLMHeadModel""", """TFCTRLModel""", """TFCTRLPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_ctrl import CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP, CTRLConfig from .tokenization_ctrl import CTRLTokenizer try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_ctrl import ( CTRL_PRETRAINED_MODEL_ARCHIVE_LIST, CTRLForSequenceClassification, CTRLLMHeadModel, CTRLModel, CTRLPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_ctrl import ( TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST, TFCTRLForSequenceClassification, TFCTRLLMHeadModel, TFCTRLModel, TFCTRLPreTrainedModel, ) else: import sys __a: Dict = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

'''simple docstring''' from __future__ import annotations from fractions import Fraction from math import gcd, sqrt def _lowerCamelCase ( lowercase : int ) -> bool: _a = int(number**0.5 ) return number == sq * sq def _lowerCamelCase ( lowercase : int , lowercase : int , lowercase : int , lowercase : int , lowercase : int , lowercase : int ) -> tuple[int, int]: _a = x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den _a = x_den * y_den * z_den _a = gcd(lowercase , lowercase ) top //= hcf bottom //= hcf return top, bottom def _lowerCamelCase ( lowercase : int = 35 ) -> int: _a = set() _a = 42 _a = Fraction(0 ) _a = 42 for x_num in range(1 , order + 1 ): for x_den in range(x_num + 1 , order + 1 ): for y_num in range(1 , order + 1 ): for y_den in range(y_num + 1 , order + 1 ): # n=1 _a = x_num * y_den + x_den * y_num _a = x_den * y_den _a = gcd(lowercase , lowercase ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _a = add_three( lowercase , lowercase , lowercase , lowercase , lowercase , lowercase ) unique_s.add(lowercase ) # n=2 _a = ( x_num * x_num * y_den * y_den + x_den * x_den * y_num * y_num ) _a = x_den * x_den * y_den * y_den if is_sq(lowercase ) and is_sq(lowercase ): _a = int(sqrt(lowercase ) ) _a = int(sqrt(lowercase ) ) _a = gcd(lowercase , lowercase ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _a = add_three( lowercase , lowercase , lowercase , lowercase , lowercase , lowercase ) unique_s.add(lowercase ) # n=-1 _a = x_num * y_num _a = x_den * y_num + x_num * y_den _a = gcd(lowercase , lowercase ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _a = add_three( lowercase , lowercase , lowercase , lowercase , lowercase , lowercase ) unique_s.add(lowercase ) # n=2 _a = x_num * x_num * y_num * y_num _a = ( x_den * x_den * y_num * y_num + x_num * x_num * y_den * y_den ) if is_sq(lowercase ) and is_sq(lowercase ): _a = int(sqrt(lowercase ) ) _a = int(sqrt(lowercase ) ) _a = gcd(lowercase , lowercase ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _a = add_three( lowercase , lowercase , lowercase , lowercase , lowercase , lowercase ) unique_s.add(lowercase ) for num, den in unique_s: total += Fraction(lowercase , lowercase ) return total.denominator + total.numerator if __name__ == "__main__": print(f"""{solution() = }""")

'''simple docstring''' import PIL.Image import PIL.ImageOps from packaging import version from PIL import Image if version.parse(version.parse(PIL.__version__).base_version) >= version.parse('9.1.0'): lowerCAmelCase_ : str = { 'linear': PIL.Image.Resampling.BILINEAR, 'bilinear': PIL.Image.Resampling.BILINEAR, 'bicubic': PIL.Image.Resampling.BICUBIC, 'lanczos': PIL.Image.Resampling.LANCZOS, 'nearest': PIL.Image.Resampling.NEAREST, } else: lowerCAmelCase_ : Union[str, Any] = { 'linear': PIL.Image.LINEAR, 'bilinear': PIL.Image.BILINEAR, 'bicubic': PIL.Image.BICUBIC, 'lanczos': PIL.Image.LANCZOS, 'nearest': PIL.Image.NEAREST, } def _lowerCamelCase ( lowercase : List[str] ) -> List[Any]: _a = (images / 2 + 0.5).clamp(0 , 1 ) _a = images.cpu().permute(0 , 2 , 3 , 1 ).float().numpy() _a = numpy_to_pil(lowercase ) return images def _lowerCamelCase ( lowercase : int ) -> List[Any]: if images.ndim == 3: _a = images[None, ...] _a = (images * 255).round().astype("uint8" ) if images.shape[-1] == 1: # special case for grayscale (single channel) images _a = [Image.fromarray(image.squeeze() , mode="L" ) for image in images] else: _a = [Image.fromarray(lowercase ) for image in images] return pil_images

import flax.linen as nn import jax.numpy as jnp from .attention_flax import FlaxTransformeraDModel from .resnet_flax import FlaxDownsampleaD, FlaxResnetBlockaD, FlaxUpsampleaD class __lowercase ( nn.Module ): """simple docstring""" _UpperCAmelCase : int _UpperCAmelCase : int _UpperCAmelCase : float = 0.0 _UpperCAmelCase : int = 1 _UpperCAmelCase : int = 1 _UpperCAmelCase : bool = True _UpperCAmelCase : bool = False _UpperCAmelCase : bool = False _UpperCAmelCase : bool = False _UpperCAmelCase : jnp.dtype = jnp.floataa def _SCREAMING_SNAKE_CASE ( self : Any): SCREAMING_SNAKE_CASE_: Any = [] SCREAMING_SNAKE_CASE_: str = [] for i in range(self.num_layers): SCREAMING_SNAKE_CASE_: Optional[Any] = self.in_channels if i == 0 else self.out_channels SCREAMING_SNAKE_CASE_: int = FlaxResnetBlockaD( in_channels=lowerCAmelCase__ , out_channels=self.out_channels , dropout_prob=self.dropout , dtype=self.dtype , ) resnets.append(lowerCAmelCase__) SCREAMING_SNAKE_CASE_: int = FlaxTransformeraDModel( in_channels=self.out_channels , n_heads=self.num_attention_heads , d_head=self.out_channels // self.num_attention_heads , depth=1 , use_linear_projection=self.use_linear_projection , only_cross_attention=self.only_cross_attention , use_memory_efficient_attention=self.use_memory_efficient_attention , dtype=self.dtype , ) attentions.append(lowerCAmelCase__) SCREAMING_SNAKE_CASE_: Optional[Any] = resnets SCREAMING_SNAKE_CASE_: str = attentions if self.add_downsample: SCREAMING_SNAKE_CASE_: List[Any] = FlaxDownsampleaD(self.out_channels , dtype=self.dtype) def __call__( self : Dict , lowerCAmelCase__ : List[str] , lowerCAmelCase__ : Tuple , lowerCAmelCase__ : Dict , lowerCAmelCase__ : str=True): SCREAMING_SNAKE_CASE_: Optional[Any] = () for resnet, attn in zip(self.resnets , self.attentions): SCREAMING_SNAKE_CASE_: int = resnet(lowerCAmelCase__ , lowerCAmelCase__ , deterministic=lowerCAmelCase__) SCREAMING_SNAKE_CASE_: str = attn(lowerCAmelCase__ , lowerCAmelCase__ , deterministic=lowerCAmelCase__) output_states += (hidden_states,) if self.add_downsample: SCREAMING_SNAKE_CASE_: Optional[Any] = self.downsamplers_a(lowerCAmelCase__) output_states += (hidden_states,) return hidden_states, output_states class __lowercase ( nn.Module ): """simple docstring""" _UpperCAmelCase : int _UpperCAmelCase : int _UpperCAmelCase : float = 0.0 _UpperCAmelCase : int = 1 _UpperCAmelCase : bool = True _UpperCAmelCase : jnp.dtype = jnp.floataa def _SCREAMING_SNAKE_CASE ( self : Optional[int]): SCREAMING_SNAKE_CASE_: List[str] = [] for i in range(self.num_layers): SCREAMING_SNAKE_CASE_: Optional[int] = self.in_channels if i == 0 else self.out_channels SCREAMING_SNAKE_CASE_: Union[str, Any] = FlaxResnetBlockaD( in_channels=lowerCAmelCase__ , out_channels=self.out_channels , dropout_prob=self.dropout , dtype=self.dtype , ) resnets.append(lowerCAmelCase__) SCREAMING_SNAKE_CASE_: Union[str, Any] = resnets if self.add_downsample: SCREAMING_SNAKE_CASE_: Union[str, Any] = FlaxDownsampleaD(self.out_channels , dtype=self.dtype) def __call__( self : List[str] , lowerCAmelCase__ : int , lowerCAmelCase__ : str , lowerCAmelCase__ : int=True): SCREAMING_SNAKE_CASE_: int = () for resnet in self.resnets: SCREAMING_SNAKE_CASE_: Tuple = resnet(lowerCAmelCase__ , lowerCAmelCase__ , deterministic=lowerCAmelCase__) output_states += (hidden_states,) if self.add_downsample: SCREAMING_SNAKE_CASE_: Any = self.downsamplers_a(lowerCAmelCase__) output_states += (hidden_states,) return hidden_states, output_states class __lowercase ( nn.Module ): """simple docstring""" _UpperCAmelCase : int _UpperCAmelCase : int _UpperCAmelCase : int _UpperCAmelCase : float = 0.0 _UpperCAmelCase : int = 1 _UpperCAmelCase : int = 1 _UpperCAmelCase : bool = True _UpperCAmelCase : bool = False _UpperCAmelCase : bool = False _UpperCAmelCase : bool = False _UpperCAmelCase : jnp.dtype = jnp.floataa def _SCREAMING_SNAKE_CASE ( self : Optional[int]): SCREAMING_SNAKE_CASE_: int = [] SCREAMING_SNAKE_CASE_: List[Any] = [] for i in range(self.num_layers): SCREAMING_SNAKE_CASE_: int = self.in_channels if (i == self.num_layers - 1) else self.out_channels SCREAMING_SNAKE_CASE_: List[str] = self.prev_output_channel if i == 0 else self.out_channels SCREAMING_SNAKE_CASE_: Tuple = FlaxResnetBlockaD( in_channels=resnet_in_channels + res_skip_channels , out_channels=self.out_channels , dropout_prob=self.dropout , dtype=self.dtype , ) resnets.append(lowerCAmelCase__) SCREAMING_SNAKE_CASE_: Tuple = FlaxTransformeraDModel( in_channels=self.out_channels , n_heads=self.num_attention_heads , d_head=self.out_channels // self.num_attention_heads , depth=1 , use_linear_projection=self.use_linear_projection , only_cross_attention=self.only_cross_attention , use_memory_efficient_attention=self.use_memory_efficient_attention , dtype=self.dtype , ) attentions.append(lowerCAmelCase__) SCREAMING_SNAKE_CASE_: int = resnets SCREAMING_SNAKE_CASE_: Union[str, Any] = attentions if self.add_upsample: SCREAMING_SNAKE_CASE_: str = FlaxUpsampleaD(self.out_channels , dtype=self.dtype) def __call__( self : List[str] , lowerCAmelCase__ : List[str] , lowerCAmelCase__ : Tuple , lowerCAmelCase__ : str , lowerCAmelCase__ : List[str] , lowerCAmelCase__ : Dict=True): for resnet, attn in zip(self.resnets , self.attentions): # pop res hidden states SCREAMING_SNAKE_CASE_: Tuple = res_hidden_states_tuple[-1] SCREAMING_SNAKE_CASE_: int = res_hidden_states_tuple[:-1] SCREAMING_SNAKE_CASE_: Tuple = jnp.concatenate((hidden_states, res_hidden_states) , axis=-1) SCREAMING_SNAKE_CASE_: Tuple = resnet(lowerCAmelCase__ , lowerCAmelCase__ , deterministic=lowerCAmelCase__) SCREAMING_SNAKE_CASE_: List[Any] = attn(lowerCAmelCase__ , lowerCAmelCase__ , deterministic=lowerCAmelCase__) if self.add_upsample: SCREAMING_SNAKE_CASE_: str = self.upsamplers_a(lowerCAmelCase__) return hidden_states class __lowercase ( nn.Module ): """simple docstring""" _UpperCAmelCase : int _UpperCAmelCase : int _UpperCAmelCase : int _UpperCAmelCase : float = 0.0 _UpperCAmelCase : int = 1 _UpperCAmelCase : bool = True _UpperCAmelCase : jnp.dtype = jnp.floataa def _SCREAMING_SNAKE_CASE ( self : List[Any]): SCREAMING_SNAKE_CASE_: str = [] for i in range(self.num_layers): SCREAMING_SNAKE_CASE_: int = self.in_channels if (i == self.num_layers - 1) else self.out_channels SCREAMING_SNAKE_CASE_: List[str] = self.prev_output_channel if i == 0 else self.out_channels SCREAMING_SNAKE_CASE_: Dict = FlaxResnetBlockaD( in_channels=resnet_in_channels + res_skip_channels , out_channels=self.out_channels , dropout_prob=self.dropout , dtype=self.dtype , ) resnets.append(lowerCAmelCase__) SCREAMING_SNAKE_CASE_: int = resnets if self.add_upsample: SCREAMING_SNAKE_CASE_: Dict = FlaxUpsampleaD(self.out_channels , dtype=self.dtype) def __call__( self : int , lowerCAmelCase__ : int , lowerCAmelCase__ : Optional[int] , lowerCAmelCase__ : List[str] , lowerCAmelCase__ : Union[str, Any]=True): for resnet in self.resnets: # pop res hidden states SCREAMING_SNAKE_CASE_: Union[str, Any] = res_hidden_states_tuple[-1] SCREAMING_SNAKE_CASE_: int = res_hidden_states_tuple[:-1] SCREAMING_SNAKE_CASE_: Optional[Any] = jnp.concatenate((hidden_states, res_hidden_states) , axis=-1) SCREAMING_SNAKE_CASE_: Dict = resnet(lowerCAmelCase__ , lowerCAmelCase__ , deterministic=lowerCAmelCase__) if self.add_upsample: SCREAMING_SNAKE_CASE_: Optional[Any] = self.upsamplers_a(lowerCAmelCase__) return hidden_states class __lowercase ( nn.Module ): """simple docstring""" _UpperCAmelCase : int _UpperCAmelCase : float = 0.0 _UpperCAmelCase : int = 1 _UpperCAmelCase : int = 1 _UpperCAmelCase : bool = False _UpperCAmelCase : bool = False _UpperCAmelCase : jnp.dtype = jnp.floataa def _SCREAMING_SNAKE_CASE ( self : List[Any]): # there is always at least one resnet SCREAMING_SNAKE_CASE_: Union[str, Any] = [ FlaxResnetBlockaD( in_channels=self.in_channels , out_channels=self.in_channels , dropout_prob=self.dropout , dtype=self.dtype , ) ] SCREAMING_SNAKE_CASE_: List[Any] = [] for _ in range(self.num_layers): SCREAMING_SNAKE_CASE_: str = FlaxTransformeraDModel( in_channels=self.in_channels , n_heads=self.num_attention_heads , d_head=self.in_channels // self.num_attention_heads , depth=1 , use_linear_projection=self.use_linear_projection , use_memory_efficient_attention=self.use_memory_efficient_attention , dtype=self.dtype , ) attentions.append(lowerCAmelCase__) SCREAMING_SNAKE_CASE_: Any = FlaxResnetBlockaD( in_channels=self.in_channels , out_channels=self.in_channels , dropout_prob=self.dropout , dtype=self.dtype , ) resnets.append(lowerCAmelCase__) SCREAMING_SNAKE_CASE_: Optional[Any] = resnets SCREAMING_SNAKE_CASE_: Dict = attentions def __call__( self : Optional[int] , lowerCAmelCase__ : int , lowerCAmelCase__ : Optional[int] , lowerCAmelCase__ : Optional[Any] , lowerCAmelCase__ : Tuple=True): SCREAMING_SNAKE_CASE_: Optional[int] = self.resnets[0](lowerCAmelCase__ , lowerCAmelCase__) for attn, resnet in zip(self.attentions , self.resnets[1:]): SCREAMING_SNAKE_CASE_: Any = attn(lowerCAmelCase__ , lowerCAmelCase__ , deterministic=lowerCAmelCase__) SCREAMING_SNAKE_CASE_: Any = resnet(lowerCAmelCase__ , lowerCAmelCase__ , deterministic=lowerCAmelCase__) return hidden_states

from typing import TYPE_CHECKING # rely on isort to merge the imports from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available UpperCAmelCase : int = { "configuration_autoformer": [ "AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP", "AutoformerConfig", ], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase : int = [ "AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST", "AutoformerForPrediction", "AutoformerModel", "AutoformerPreTrainedModel", ] if TYPE_CHECKING: from .configuration_autoformer import ( AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, AutoformerConfig, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_autoformer import ( AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, AutoformerForPrediction, AutoformerModel, AutoformerPreTrainedModel, ) else: import sys UpperCAmelCase : str = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)

'''simple docstring''' from typing import Optional import torch import torch.utils.checkpoint from torch import Tensor, nn from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss from ...activations import ACTaFN from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward from ...modeling_outputs import ( BaseModelOutputWithNoAttention, BaseModelOutputWithPoolingAndNoAttention, ImageClassifierOutputWithNoAttention, ) from ...modeling_utils import PreTrainedModel from ...utils import logging from .configuration_regnet import RegNetConfig __snake_case : Union[str, Any] = logging.get_logger(__name__) # General docstring __snake_case : Optional[Any] = 'RegNetConfig' # Base docstring __snake_case : List[str] = 'facebook/regnet-y-040' __snake_case : Optional[Any] = [1, 1_088, 7, 7] # Image classification docstring __snake_case : Any = 'facebook/regnet-y-040' __snake_case : List[str] = 'tabby, tabby cat' __snake_case : Union[str, Any] = [ 'facebook/regnet-y-040', # See all regnet models at https://huggingface.co/models?filter=regnet ] class __UpperCAmelCase ( nn.Module ): '''simple docstring''' def __init__( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE = 3 , _SCREAMING_SNAKE_CASE = 1 , _SCREAMING_SNAKE_CASE = 1 , _SCREAMING_SNAKE_CASE = "relu" , ) -> Optional[int]: super().__init__() A_ = nn.Convad( _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , kernel_size=_SCREAMING_SNAKE_CASE , stride=_SCREAMING_SNAKE_CASE , padding=kernel_size // 2 , groups=_SCREAMING_SNAKE_CASE , bias=_SCREAMING_SNAKE_CASE , ) A_ = nn.BatchNormad(_SCREAMING_SNAKE_CASE ) A_ = ACTaFN[activation] if activation is not None else nn.Identity() def __A ( self , _SCREAMING_SNAKE_CASE ) -> List[str]: A_ = self.convolution(_SCREAMING_SNAKE_CASE ) A_ = self.normalization(_SCREAMING_SNAKE_CASE ) A_ = self.activation(_SCREAMING_SNAKE_CASE ) return hidden_state class __UpperCAmelCase ( nn.Module ): '''simple docstring''' def __init__( self , _SCREAMING_SNAKE_CASE ) -> Any: super().__init__() A_ = RegNetConvLayer( config.num_channels , config.embedding_size , kernel_size=3 , stride=2 , activation=config.hidden_act ) A_ = config.num_channels def __A ( self , _SCREAMING_SNAKE_CASE ) -> int: A_ = pixel_values.shape[1] if num_channels != self.num_channels: raise ValueError( '''Make sure that the channel dimension of the pixel values match with the one set in the configuration.''' ) A_ = self.embedder(_SCREAMING_SNAKE_CASE ) return hidden_state class __UpperCAmelCase ( nn.Module ): '''simple docstring''' def __init__( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE = 2 ) -> List[str]: super().__init__() A_ = nn.Convad(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , kernel_size=1 , stride=_SCREAMING_SNAKE_CASE , bias=_SCREAMING_SNAKE_CASE ) A_ = nn.BatchNormad(_SCREAMING_SNAKE_CASE ) def __A ( self , _SCREAMING_SNAKE_CASE ) -> Tensor: A_ = self.convolution(_SCREAMING_SNAKE_CASE ) A_ = self.normalization(_SCREAMING_SNAKE_CASE ) return hidden_state class __UpperCAmelCase ( nn.Module ): '''simple docstring''' def __init__( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) -> Any: super().__init__() A_ = nn.AdaptiveAvgPoolad((1, 1) ) A_ = nn.Sequential( nn.Convad(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , kernel_size=1 ) , nn.ReLU() , nn.Convad(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , kernel_size=1 ) , nn.Sigmoid() , ) def __A ( self , _SCREAMING_SNAKE_CASE ) -> int: # b c h w -> b c 1 1 A_ = self.pooler(_SCREAMING_SNAKE_CASE ) A_ = self.attention(_SCREAMING_SNAKE_CASE ) A_ = hidden_state * attention return hidden_state class __UpperCAmelCase ( nn.Module ): '''simple docstring''' def __init__( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE = 1 ) -> int: super().__init__() A_ = in_channels != out_channels or stride != 1 A_ = max(1 , out_channels // config.groups_width ) A_ = ( RegNetShortCut(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , stride=_SCREAMING_SNAKE_CASE ) if should_apply_shortcut else nn.Identity() ) A_ = nn.Sequential( RegNetConvLayer(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , kernel_size=1 , activation=config.hidden_act ) , RegNetConvLayer(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , stride=_SCREAMING_SNAKE_CASE , groups=_SCREAMING_SNAKE_CASE , activation=config.hidden_act ) , RegNetConvLayer(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , kernel_size=1 , activation=_SCREAMING_SNAKE_CASE ) , ) A_ = ACTaFN[config.hidden_act] def __A ( self , _SCREAMING_SNAKE_CASE ) -> Optional[Any]: A_ = hidden_state A_ = self.layer(_SCREAMING_SNAKE_CASE ) A_ = self.shortcut(_SCREAMING_SNAKE_CASE ) hidden_state += residual A_ = self.activation(_SCREAMING_SNAKE_CASE ) return hidden_state class __UpperCAmelCase ( nn.Module ): '''simple docstring''' def __init__( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE = 1 ) -> str: super().__init__() A_ = in_channels != out_channels or stride != 1 A_ = max(1 , out_channels // config.groups_width ) A_ = ( RegNetShortCut(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , stride=_SCREAMING_SNAKE_CASE ) if should_apply_shortcut else nn.Identity() ) A_ = nn.Sequential( RegNetConvLayer(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , kernel_size=1 , activation=config.hidden_act ) , RegNetConvLayer(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , stride=_SCREAMING_SNAKE_CASE , groups=_SCREAMING_SNAKE_CASE , activation=config.hidden_act ) , RegNetSELayer(_SCREAMING_SNAKE_CASE , reduced_channels=int(round(in_channels / 4 ) ) ) , RegNetConvLayer(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , kernel_size=1 , activation=_SCREAMING_SNAKE_CASE ) , ) A_ = ACTaFN[config.hidden_act] def __A ( self , _SCREAMING_SNAKE_CASE ) -> Optional[Any]: A_ = hidden_state A_ = self.layer(_SCREAMING_SNAKE_CASE ) A_ = self.shortcut(_SCREAMING_SNAKE_CASE ) hidden_state += residual A_ = self.activation(_SCREAMING_SNAKE_CASE ) return hidden_state class __UpperCAmelCase ( nn.Module ): '''simple docstring''' def __init__( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE = 2 , _SCREAMING_SNAKE_CASE = 2 , ) -> List[str]: super().__init__() A_ = RegNetXLayer if config.layer_type == '''x''' else RegNetYLayer A_ = nn.Sequential( # downsampling is done in the first layer with stride of 2 layer( _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , stride=_SCREAMING_SNAKE_CASE , ) , *[layer(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) for _ in range(depth - 1 )] , ) def __A ( self , _SCREAMING_SNAKE_CASE ) -> List[Any]: A_ = self.layers(_SCREAMING_SNAKE_CASE ) return hidden_state class __UpperCAmelCase ( nn.Module ): '''simple docstring''' def __init__( self , _SCREAMING_SNAKE_CASE ) -> Optional[Any]: super().__init__() A_ = nn.ModuleList([] ) # based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input self.stages.append( RegNetStage( _SCREAMING_SNAKE_CASE , config.embedding_size , config.hidden_sizes[0] , stride=2 if config.downsample_in_first_stage else 1 , depth=config.depths[0] , ) ) A_ = zip(config.hidden_sizes , config.hidden_sizes[1:] ) for (in_channels, out_channels), depth in zip(_SCREAMING_SNAKE_CASE , config.depths[1:] ): self.stages.append(RegNetStage(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , depth=_SCREAMING_SNAKE_CASE ) ) def __A ( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE = False , _SCREAMING_SNAKE_CASE = True ) -> BaseModelOutputWithNoAttention: A_ = () if output_hidden_states else None for stage_module in self.stages: if output_hidden_states: A_ = hidden_states + (hidden_state,) A_ = stage_module(_SCREAMING_SNAKE_CASE ) if output_hidden_states: A_ = hidden_states + (hidden_state,) if not return_dict: return tuple(v for v in [hidden_state, hidden_states] if v is not None ) return BaseModelOutputWithNoAttention(last_hidden_state=_SCREAMING_SNAKE_CASE , hidden_states=_SCREAMING_SNAKE_CASE ) class __UpperCAmelCase ( _UpperCamelCase ): '''simple docstring''' __lowercase : List[str] = RegNetConfig __lowercase : int = 'regnet' __lowercase : Union[str, Any] = 'pixel_values' __lowercase : str = True def __A ( self , _SCREAMING_SNAKE_CASE ) -> Optional[int]: if isinstance(_SCREAMING_SNAKE_CASE , nn.Convad ): nn.init.kaiming_normal_(module.weight , mode='''fan_out''' , nonlinearity='''relu''' ) elif isinstance(_SCREAMING_SNAKE_CASE , (nn.BatchNormad, nn.GroupNorm) ): nn.init.constant_(module.weight , 1 ) nn.init.constant_(module.bias , 0 ) def __A ( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE=False ) -> int: if isinstance(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ): A_ = value __snake_case : str = R'\n This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it\n as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and\n behavior.\n\n Parameters:\n config ([`RegNetConfig`]): Model configuration class with all the parameters of the model.\n Initializing with a config file does not load the weights associated with the model, only the\n configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.\n' __snake_case : Union[str, Any] = R'\n Args:\n pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):\n Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n [`ConvNextImageProcessor.__call__`] for details.\n\n output_hidden_states (`bool`, *optional*):\n Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n more detail.\n return_dict (`bool`, *optional*):\n Whether or not to return a [`~file_utils.ModelOutput`] instead of a plain tuple.\n' @add_start_docstrings( 'The bare RegNet model outputting raw features without any specific head on top.' , _UpperCamelCase , ) # Copied from transformers.models.resnet.modeling_resnet.ResNetModel with RESNET->REGNET,ResNet->RegNet class __UpperCAmelCase ( _UpperCamelCase ): '''simple docstring''' def __init__( self , _SCREAMING_SNAKE_CASE ) -> List[str]: super().__init__(_SCREAMING_SNAKE_CASE ) A_ = config A_ = RegNetEmbeddings(_SCREAMING_SNAKE_CASE ) A_ = RegNetEncoder(_SCREAMING_SNAKE_CASE ) A_ = nn.AdaptiveAvgPoolad((1, 1) ) # Initialize weights and apply final processing self.post_init() @add_start_docstrings_to_model_forward(_SCREAMING_SNAKE_CASE ) @add_code_sample_docstrings( checkpoint=_CHECKPOINT_FOR_DOC , output_type=_SCREAMING_SNAKE_CASE , config_class=_CONFIG_FOR_DOC , modality='''vision''' , expected_output=_EXPECTED_OUTPUT_SHAPE , ) def __A ( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE = None , _SCREAMING_SNAKE_CASE = None ) -> BaseModelOutputWithPoolingAndNoAttention: A_ = ( output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states ) A_ = return_dict if return_dict is not None else self.config.use_return_dict A_ = self.embedder(_SCREAMING_SNAKE_CASE ) A_ = self.encoder( _SCREAMING_SNAKE_CASE , output_hidden_states=_SCREAMING_SNAKE_CASE , return_dict=_SCREAMING_SNAKE_CASE ) A_ = encoder_outputs[0] A_ = self.pooler(_SCREAMING_SNAKE_CASE ) if not return_dict: return (last_hidden_state, pooled_output) + encoder_outputs[1:] return BaseModelOutputWithPoolingAndNoAttention( last_hidden_state=_SCREAMING_SNAKE_CASE , pooler_output=_SCREAMING_SNAKE_CASE , hidden_states=encoder_outputs.hidden_states , ) @add_start_docstrings( '\n RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n ImageNet.\n ' , _UpperCamelCase , ) # Copied from transformers.models.resnet.modeling_resnet.ResNetForImageClassification with RESNET->REGNET,ResNet->RegNet,resnet->regnet class __UpperCAmelCase ( _UpperCamelCase ): '''simple docstring''' def __init__( self , _SCREAMING_SNAKE_CASE ) -> Optional[int]: super().__init__(_SCREAMING_SNAKE_CASE ) A_ = config.num_labels A_ = RegNetModel(_SCREAMING_SNAKE_CASE ) # classification head A_ = nn.Sequential( nn.Flatten() , nn.Linear(config.hidden_sizes[-1] , config.num_labels ) if config.num_labels > 0 else nn.Identity() , ) # initialize weights and apply final processing self.post_init() @add_start_docstrings_to_model_forward(_SCREAMING_SNAKE_CASE ) @add_code_sample_docstrings( checkpoint=_IMAGE_CLASS_CHECKPOINT , output_type=_SCREAMING_SNAKE_CASE , config_class=_CONFIG_FOR_DOC , expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT , ) def __A ( self , _SCREAMING_SNAKE_CASE = None , _SCREAMING_SNAKE_CASE = None , _SCREAMING_SNAKE_CASE = None , _SCREAMING_SNAKE_CASE = None , ) -> ImageClassifierOutputWithNoAttention: A_ = return_dict if return_dict is not None else self.config.use_return_dict A_ = self.regnet(_SCREAMING_SNAKE_CASE , output_hidden_states=_SCREAMING_SNAKE_CASE , return_dict=_SCREAMING_SNAKE_CASE ) A_ = outputs.pooler_output if return_dict else outputs[1] A_ = self.classifier(_SCREAMING_SNAKE_CASE ) A_ = None if labels is not None: if self.config.problem_type is None: if self.num_labels == 1: A_ = '''regression''' elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int): A_ = '''single_label_classification''' else: A_ = '''multi_label_classification''' if self.config.problem_type == "regression": A_ = MSELoss() if self.num_labels == 1: A_ = loss_fct(logits.squeeze() , labels.squeeze() ) else: A_ = loss_fct(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) elif self.config.problem_type == "single_label_classification": A_ = CrossEntropyLoss() A_ = loss_fct(logits.view(-1 , self.num_labels ) , labels.view(-1 ) ) elif self.config.problem_type == "multi_label_classification": A_ = BCEWithLogitsLoss() A_ = loss_fct(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) if not return_dict: A_ = (logits,) + outputs[2:] return (loss,) + output if loss is not None else output return ImageClassifierOutputWithNoAttention(loss=_SCREAMING_SNAKE_CASE , logits=_SCREAMING_SNAKE_CASE , hidden_states=outputs.hidden_states )

'''simple docstring''' import absl # noqa: F401 # Here to have a nice missing dependency error message early on import nltk # noqa: F401 # Here to have a nice missing dependency error message early on import numpy # noqa: F401 # Here to have a nice missing dependency error message early on import six # noqa: F401 # Here to have a nice missing dependency error message early on from rouge_score import rouge_scorer, scoring import datasets __snake_case : Any = '\\n@inproceedings{lin-2004-rouge,\n title = "{ROUGE}: A Package for Automatic Evaluation of Summaries",\n author = "Lin, Chin-Yew",\n booktitle = "Text Summarization Branches Out",\n month = jul,\n year = "2004",\n address = "Barcelona, Spain",\n publisher = "Association for Computational Linguistics",\n url = "https://www.aclweb.org/anthology/W04-1013",\n pages = "74--81",\n}\n' __snake_case : Dict = '\\nROUGE, or Recall-Oriented Understudy for Gisting Evaluation, is a set of metrics and a software package used for\nevaluating automatic summarization and machine translation software in natural language processing.\nThe metrics compare an automatically produced summary or translation against a reference or a set of references (human-produced) summary or translation.\n\nNote that ROUGE is case insensitive, meaning that upper case letters are treated the same way as lower case letters.\n\nThis metrics is a wrapper around Google Research reimplementation of ROUGE:\nhttps://github.com/google-research/google-research/tree/master/rouge\n' __snake_case : Optional[int] = '\nCalculates average rouge scores for a list of hypotheses and references\nArgs:\n predictions: list of predictions to score. Each prediction\n should be a string with tokens separated by spaces.\n references: list of reference for each prediction. Each\n reference should be a string with tokens separated by spaces.\n rouge_types: A list of rouge types to calculate.\n Valid names:\n `"rouge{n}"` (e.g. `"rouge1"`, `"rouge2"`) where: {n} is the n-gram based scoring,\n `"rougeL"`: Longest common subsequence based scoring.\n `"rougeLSum"`: rougeLsum splits text using `"\n"`.\n See details in https://github.com/huggingface/datasets/issues/617\n use_stemmer: Bool indicating whether Porter stemmer should be used to strip word suffixes.\n use_aggregator: Return aggregates if this is set to True\nReturns:\n rouge1: rouge_1 (precision, recall, f1),\n rouge2: rouge_2 (precision, recall, f1),\n rougeL: rouge_l (precision, recall, f1),\n rougeLsum: rouge_lsum (precision, recall, f1)\nExamples:\n\n >>> rouge = datasets.load_metric(\'rouge\')\n >>> predictions = ["hello there", "general kenobi"]\n >>> references = ["hello there", "general kenobi"]\n >>> results = rouge.compute(predictions=predictions, references=references)\n >>> print(list(results.keys()))\n [\'rouge1\', \'rouge2\', \'rougeL\', \'rougeLsum\']\n >>> print(results["rouge1"])\n AggregateScore(low=Score(precision=1.0, recall=1.0, fmeasure=1.0), mid=Score(precision=1.0, recall=1.0, fmeasure=1.0), high=Score(precision=1.0, recall=1.0, fmeasure=1.0))\n >>> print(results["rouge1"].mid.fmeasure)\n 1.0\n' @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class __UpperCAmelCase ( datasets.Metric ): '''simple docstring''' def __A ( self ) -> List[str]: return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { '''predictions''': datasets.Value('''string''' , id='''sequence''' ), '''references''': datasets.Value('''string''' , id='''sequence''' ), } ) , codebase_urls=['''https://github.com/google-research/google-research/tree/master/rouge'''] , reference_urls=[ '''https://en.wikipedia.org/wiki/ROUGE_(metric)''', '''https://github.com/google-research/google-research/tree/master/rouge''', ] , ) def __A ( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE=None , _SCREAMING_SNAKE_CASE=True , _SCREAMING_SNAKE_CASE=False ) -> Optional[int]: if rouge_types is None: A_ = ['''rouge1''', '''rouge2''', '''rougeL''', '''rougeLsum'''] A_ = rouge_scorer.RougeScorer(rouge_types=_SCREAMING_SNAKE_CASE , use_stemmer=_SCREAMING_SNAKE_CASE ) if use_aggregator: A_ = scoring.BootstrapAggregator() else: A_ = [] for ref, pred in zip(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ): A_ = scorer.score(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) if use_aggregator: aggregator.add_scores(_SCREAMING_SNAKE_CASE ) else: scores.append(_SCREAMING_SNAKE_CASE ) if use_aggregator: A_ = aggregator.aggregate() else: A_ = {} for key in scores[0]: A_ = [score[key] for score in scores] return result

'''simple docstring''' from typing import Callable, List, Optional, Union import PIL import torch from transformers import ( CLIPImageProcessor, CLIPSegForImageSegmentation, CLIPSegProcessor, CLIPTextModel, CLIPTokenizer, ) from diffusers import DiffusionPipeline from diffusers.configuration_utils import FrozenDict from diffusers.models import AutoencoderKL, UNetaDConditionModel from diffusers.pipelines.stable_diffusion import StableDiffusionInpaintPipeline from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker from diffusers.schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler from diffusers.utils import deprecate, is_accelerate_available, logging A_ = logging.get_logger(__name__) # pylint: disable=invalid-name class _snake_case ( _a ): def __init__( self : List[Any] ,SCREAMING_SNAKE_CASE__ : CLIPSegForImageSegmentation ,SCREAMING_SNAKE_CASE__ : CLIPSegProcessor ,SCREAMING_SNAKE_CASE__ : AutoencoderKL ,SCREAMING_SNAKE_CASE__ : CLIPTextModel ,SCREAMING_SNAKE_CASE__ : CLIPTokenizer ,SCREAMING_SNAKE_CASE__ : UNetaDConditionModel ,SCREAMING_SNAKE_CASE__ : Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler] ,SCREAMING_SNAKE_CASE__ : StableDiffusionSafetyChecker ,SCREAMING_SNAKE_CASE__ : CLIPImageProcessor ,): super().__init__() if hasattr(scheduler.config ,"steps_offset" ) and scheduler.config.steps_offset != 1: SCREAMING_SNAKE_CASE:Union[str, Any] = ( F'''The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`''' F''' should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure ''' "to update the config accordingly as leaving `steps_offset` might led to incorrect results" " in future versions. If you have downloaded this checkpoint from the Hugging Face Hub," " it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json`" " file" ) deprecate("steps_offset!=1" ,"1.0.0" ,SCREAMING_SNAKE_CASE__ ,standard_warn=SCREAMING_SNAKE_CASE__ ) SCREAMING_SNAKE_CASE:Tuple = dict(scheduler.config ) SCREAMING_SNAKE_CASE:Union[str, Any] = 1 SCREAMING_SNAKE_CASE:Dict = FrozenDict(SCREAMING_SNAKE_CASE__ ) if hasattr(scheduler.config ,"skip_prk_steps" ) and scheduler.config.skip_prk_steps is False: SCREAMING_SNAKE_CASE:List[Any] = ( F'''The configuration file of this scheduler: {scheduler} has not set the configuration''' " `skip_prk_steps`. `skip_prk_steps` should be set to True in the configuration file. Please make" " sure to update the config accordingly as not setting `skip_prk_steps` in the config might lead to" " incorrect results in future versions. If you have downloaded this checkpoint from the Hugging Face" " Hub, it would be very nice if you could open a Pull request for the" " `scheduler/scheduler_config.json` file" ) deprecate("skip_prk_steps not set" ,"1.0.0" ,SCREAMING_SNAKE_CASE__ ,standard_warn=SCREAMING_SNAKE_CASE__ ) SCREAMING_SNAKE_CASE:Tuple = dict(scheduler.config ) SCREAMING_SNAKE_CASE:int = True SCREAMING_SNAKE_CASE:Optional[int] = FrozenDict(SCREAMING_SNAKE_CASE__ ) if safety_checker is None: logger.warning( F'''You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure''' " that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered" " results in services or applications open to the public. Both the diffusers team and Hugging Face" " strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling" " it only for use-cases that involve analyzing network behavior or auditing its results. For more" " information, please have a look at https://github.com/huggingface/diffusers/pull/254 ." ) self.register_modules( segmentation_model=SCREAMING_SNAKE_CASE__ ,segmentation_processor=SCREAMING_SNAKE_CASE__ ,vae=SCREAMING_SNAKE_CASE__ ,text_encoder=SCREAMING_SNAKE_CASE__ ,tokenizer=SCREAMING_SNAKE_CASE__ ,unet=SCREAMING_SNAKE_CASE__ ,scheduler=SCREAMING_SNAKE_CASE__ ,safety_checker=SCREAMING_SNAKE_CASE__ ,feature_extractor=SCREAMING_SNAKE_CASE__ ,) def __UpperCamelCase ( self : int ,SCREAMING_SNAKE_CASE__ : Optional[Union[str, int]] = "auto" ): if slice_size == "auto": # half the attention head size is usually a good trade-off between # speed and memory SCREAMING_SNAKE_CASE:Optional[Any] = self.unet.config.attention_head_dim // 2 self.unet.set_attention_slice(SCREAMING_SNAKE_CASE__ ) def __UpperCamelCase ( self : str ): self.enable_attention_slicing(SCREAMING_SNAKE_CASE__ ) def __UpperCamelCase ( self : List[str] ): if is_accelerate_available(): from accelerate import cpu_offload else: raise ImportError("Please install accelerate via `pip install accelerate`" ) SCREAMING_SNAKE_CASE:str = torch.device("cuda" ) for cpu_offloaded_model in [self.unet, self.text_encoder, self.vae, self.safety_checker]: if cpu_offloaded_model is not None: cpu_offload(SCREAMING_SNAKE_CASE__ ,SCREAMING_SNAKE_CASE__ ) @property # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device def __UpperCamelCase ( self : Any ): if self.device != torch.device("meta" ) or not hasattr(self.unet ,"_hf_hook" ): return self.device for module in self.unet.modules(): if ( hasattr(SCREAMING_SNAKE_CASE__ ,"_hf_hook" ) and hasattr(module._hf_hook ,"execution_device" ) and module._hf_hook.execution_device is not None ): return torch.device(module._hf_hook.execution_device ) return self.device @torch.no_grad() def __call__( self : Dict ,SCREAMING_SNAKE_CASE__ : Union[str, List[str]] ,SCREAMING_SNAKE_CASE__ : Union[torch.FloatTensor, PIL.Image.Image] ,SCREAMING_SNAKE_CASE__ : str ,SCREAMING_SNAKE_CASE__ : int = 512 ,SCREAMING_SNAKE_CASE__ : int = 512 ,SCREAMING_SNAKE_CASE__ : int = 50 ,SCREAMING_SNAKE_CASE__ : float = 7.5 ,SCREAMING_SNAKE_CASE__ : Optional[Union[str, List[str]]] = None ,SCREAMING_SNAKE_CASE__ : Optional[int] = 1 ,SCREAMING_SNAKE_CASE__ : float = 0.0 ,SCREAMING_SNAKE_CASE__ : Optional[torch.Generator] = None ,SCREAMING_SNAKE_CASE__ : Optional[torch.FloatTensor] = None ,SCREAMING_SNAKE_CASE__ : Optional[str] = "pil" ,SCREAMING_SNAKE_CASE__ : bool = True ,SCREAMING_SNAKE_CASE__ : Optional[Callable[[int, int, torch.FloatTensor], None]] = None ,SCREAMING_SNAKE_CASE__ : int = 1 ,**SCREAMING_SNAKE_CASE__ : Dict ,): SCREAMING_SNAKE_CASE:str = self.segmentation_processor( text=[text] ,images=[image] ,padding="max_length" ,return_tensors="pt" ).to(self.device ) SCREAMING_SNAKE_CASE:Union[str, Any] = self.segmentation_model(**SCREAMING_SNAKE_CASE__ ) SCREAMING_SNAKE_CASE:Optional[int] = torch.sigmoid(outputs.logits ).cpu().detach().unsqueeze(-1 ).numpy() SCREAMING_SNAKE_CASE:Optional[Any] = self.numpy_to_pil(SCREAMING_SNAKE_CASE__ )[0].resize(image.size ) # Run inpainting pipeline with the generated mask SCREAMING_SNAKE_CASE:Any = StableDiffusionInpaintPipeline( vae=self.vae ,text_encoder=self.text_encoder ,tokenizer=self.tokenizer ,unet=self.unet ,scheduler=self.scheduler ,safety_checker=self.safety_checker ,feature_extractor=self.feature_extractor ,) return inpainting_pipeline( prompt=SCREAMING_SNAKE_CASE__ ,image=SCREAMING_SNAKE_CASE__ ,mask_image=SCREAMING_SNAKE_CASE__ ,height=SCREAMING_SNAKE_CASE__ ,width=SCREAMING_SNAKE_CASE__ ,num_inference_steps=SCREAMING_SNAKE_CASE__ ,guidance_scale=SCREAMING_SNAKE_CASE__ ,negative_prompt=SCREAMING_SNAKE_CASE__ ,num_images_per_prompt=SCREAMING_SNAKE_CASE__ ,eta=SCREAMING_SNAKE_CASE__ ,generator=SCREAMING_SNAKE_CASE__ ,latents=SCREAMING_SNAKE_CASE__ ,output_type=SCREAMING_SNAKE_CASE__ ,return_dict=SCREAMING_SNAKE_CASE__ ,callback=SCREAMING_SNAKE_CASE__ ,callback_steps=SCREAMING_SNAKE_CASE__ ,)

'''simple docstring''' from __future__ import annotations A_ = list[list[int]] # assigning initial values to the grid A_ = [ [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 A_ = [ [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_ ( snake_case , snake_case , snake_case , snake_case ): 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_ ( snake_case ): for i in range(9 ): for j in range(9 ): if grid[i][j] == 0: return i, j return None def A_ ( snake_case ): if location := find_empty_location(snake_case ): SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE:Optional[int] = location else: # If the location is ``None``, then the grid is solved. return grid for digit in range(1 , 10 ): if is_safe(snake_case , snake_case , snake_case , snake_case ): SCREAMING_SNAKE_CASE:List[str] = digit if sudoku(snake_case ) is not None: return grid SCREAMING_SNAKE_CASE:List[Any] = 0 return None def A_ ( snake_case ): for row in grid: for cell in row: print(snake_case , 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:") A_ = sudoku(example_grid) if solution is not None: print_solution(solution) else: print("Cannot find a solution.")

"""simple docstring""" from math import factorial def __lowerCamelCase ( a_ : int = 1_00 ) -> int: return sum(int(a_ ) for x in str(factorial(a_ ) ) ) if __name__ == "__main__": print(solution(int(input("Enter the Number: ").strip())))

"""simple docstring""" import numpy as np import torch import tqdm from ...models.unet_ad import UNetaDModel from ...pipelines import DiffusionPipeline from ...utils import randn_tensor from ...utils.dummy_pt_objects import DDPMScheduler class _SCREAMING_SNAKE_CASE( A ): def __init__( self ,SCREAMING_SNAKE_CASE__ ,SCREAMING_SNAKE_CASE__ ,SCREAMING_SNAKE_CASE__ ,SCREAMING_SNAKE_CASE__ ,) -> Optional[int]: """simple docstring""" super().__init__() __SCREAMING_SNAKE_CASE :Any = value_function __SCREAMING_SNAKE_CASE :List[str] = unet __SCREAMING_SNAKE_CASE :int = scheduler __SCREAMING_SNAKE_CASE :Optional[int] = env __SCREAMING_SNAKE_CASE :Optional[int] = env.get_dataset() __SCREAMING_SNAKE_CASE :str = {} for key in self.data.keys(): try: __SCREAMING_SNAKE_CASE :Optional[Any] = self.data[key].mean() except: # noqa: E722 pass __SCREAMING_SNAKE_CASE :Dict = {} for key in self.data.keys(): try: __SCREAMING_SNAKE_CASE :str = self.data[key].std() except: # noqa: E722 pass __SCREAMING_SNAKE_CASE :Optional[int] = env.observation_space.shape[0] __SCREAMING_SNAKE_CASE :int = env.action_space.shape[0] def _UpperCamelCase ( self ,SCREAMING_SNAKE_CASE__ ,SCREAMING_SNAKE_CASE__ ) -> str: """simple docstring""" return (x_in - self.means[key]) / self.stds[key] def _UpperCamelCase ( self ,SCREAMING_SNAKE_CASE__ ,SCREAMING_SNAKE_CASE__ ) -> Dict: """simple docstring""" return x_in * self.stds[key] + self.means[key] def _UpperCamelCase ( self ,SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: """simple docstring""" if type(SCREAMING_SNAKE_CASE__ ) is dict: return {k: self.to_torch(SCREAMING_SNAKE_CASE__ ) for k, v in x_in.items()} elif torch.is_tensor(SCREAMING_SNAKE_CASE__ ): return x_in.to(self.unet.device ) return torch.tensor(SCREAMING_SNAKE_CASE__ ,device=self.unet.device ) def _UpperCamelCase ( self ,SCREAMING_SNAKE_CASE__ ,SCREAMING_SNAKE_CASE__ ,SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: """simple docstring""" for key, val in cond.items(): __SCREAMING_SNAKE_CASE :Dict = val.clone() return x_in def _UpperCamelCase ( self ,SCREAMING_SNAKE_CASE__ ,SCREAMING_SNAKE_CASE__ ,SCREAMING_SNAKE_CASE__ ,SCREAMING_SNAKE_CASE__ ) -> int: """simple docstring""" __SCREAMING_SNAKE_CASE :Union[str, Any] = x.shape[0] __SCREAMING_SNAKE_CASE :List[Any] = None for i in tqdm.tqdm(self.scheduler.timesteps ): # create batch of timesteps to pass into model __SCREAMING_SNAKE_CASE :Tuple = torch.full((batch_size,) ,SCREAMING_SNAKE_CASE__ ,device=self.unet.device ,dtype=torch.long ) for _ in range(SCREAMING_SNAKE_CASE__ ): with torch.enable_grad(): x.requires_grad_() # permute to match dimension for pre-trained models __SCREAMING_SNAKE_CASE :str = self.value_function(x.permute(0 ,2 ,1 ) ,SCREAMING_SNAKE_CASE__ ).sample __SCREAMING_SNAKE_CASE :Union[str, Any] = torch.autograd.grad([y.sum()] ,[x] )[0] __SCREAMING_SNAKE_CASE :int = self.scheduler._get_variance(SCREAMING_SNAKE_CASE__ ) __SCREAMING_SNAKE_CASE :Optional[Any] = torch.exp(0.5 * posterior_variance ) __SCREAMING_SNAKE_CASE :List[str] = model_std * grad __SCREAMING_SNAKE_CASE :Dict = 0 __SCREAMING_SNAKE_CASE :List[Any] = x.detach() __SCREAMING_SNAKE_CASE :Union[str, Any] = x + scale * grad __SCREAMING_SNAKE_CASE :Any = self.reset_xa(SCREAMING_SNAKE_CASE__ ,SCREAMING_SNAKE_CASE__ ,self.action_dim ) __SCREAMING_SNAKE_CASE :Optional[int] = self.unet(x.permute(0 ,2 ,1 ) ,SCREAMING_SNAKE_CASE__ ).sample.permute(0 ,2 ,1 ) # TODO: verify deprecation of this kwarg __SCREAMING_SNAKE_CASE :Optional[int] = self.scheduler.step(SCREAMING_SNAKE_CASE__ ,SCREAMING_SNAKE_CASE__ ,SCREAMING_SNAKE_CASE__ ,predict_epsilon=SCREAMING_SNAKE_CASE__ )['''prev_sample'''] # apply conditions to the trajectory (set the initial state) __SCREAMING_SNAKE_CASE :List[str] = self.reset_xa(SCREAMING_SNAKE_CASE__ ,SCREAMING_SNAKE_CASE__ ,self.action_dim ) __SCREAMING_SNAKE_CASE :Dict = self.to_torch(SCREAMING_SNAKE_CASE__ ) return x, y def __call__( self ,SCREAMING_SNAKE_CASE__ ,SCREAMING_SNAKE_CASE__=64 ,SCREAMING_SNAKE_CASE__=32 ,SCREAMING_SNAKE_CASE__=2 ,SCREAMING_SNAKE_CASE__=0.1 ) -> Union[str, Any]: """simple docstring""" __SCREAMING_SNAKE_CASE :Tuple = self.normalize(SCREAMING_SNAKE_CASE__ ,'''observations''' ) __SCREAMING_SNAKE_CASE :List[Any] = obs[None].repeat(SCREAMING_SNAKE_CASE__ ,axis=0 ) __SCREAMING_SNAKE_CASE :str = {0: self.to_torch(SCREAMING_SNAKE_CASE__ )} __SCREAMING_SNAKE_CASE :Optional[Any] = (batch_size, planning_horizon, self.state_dim + self.action_dim) # generate initial noise and apply our conditions (to make the trajectories start at current state) __SCREAMING_SNAKE_CASE :Optional[int] = randn_tensor(SCREAMING_SNAKE_CASE__ ,device=self.unet.device ) __SCREAMING_SNAKE_CASE :Tuple = self.reset_xa(SCREAMING_SNAKE_CASE__ ,SCREAMING_SNAKE_CASE__ ,self.action_dim ) __SCREAMING_SNAKE_CASE :Any = self.to_torch(SCREAMING_SNAKE_CASE__ ) # run the diffusion process __SCREAMING_SNAKE_CASE ,__SCREAMING_SNAKE_CASE :Tuple = self.run_diffusion(SCREAMING_SNAKE_CASE__ ,SCREAMING_SNAKE_CASE__ ,SCREAMING_SNAKE_CASE__ ,SCREAMING_SNAKE_CASE__ ) # sort output trajectories by value __SCREAMING_SNAKE_CASE :Any = y.argsort(0 ,descending=SCREAMING_SNAKE_CASE__ ).squeeze() __SCREAMING_SNAKE_CASE :Any = x[sorted_idx] __SCREAMING_SNAKE_CASE :str = sorted_values[:, :, : self.action_dim] __SCREAMING_SNAKE_CASE :Union[str, Any] = actions.detach().cpu().numpy() __SCREAMING_SNAKE_CASE :Optional[int] = self.de_normalize(SCREAMING_SNAKE_CASE__ ,key='''actions''' ) # select the action with the highest value if y is not None: __SCREAMING_SNAKE_CASE :Optional[int] = 0 else: # if we didn't run value guiding, select a random action __SCREAMING_SNAKE_CASE :Any = np.random.randint(0 ,SCREAMING_SNAKE_CASE__ ) __SCREAMING_SNAKE_CASE :int = denorm_actions[selected_index, 0] return denorm_actions

'''simple docstring''' from __future__ import annotations from fractions import Fraction from math import gcd, sqrt def snake_case_ ( _lowerCAmelCase : int ) -> bool: UpperCAmelCase : int = int(number**0.5 ) return number == sq * sq def snake_case_ ( _lowerCAmelCase : int , _lowerCAmelCase : int , _lowerCAmelCase : int , _lowerCAmelCase : int , _lowerCAmelCase : int , _lowerCAmelCase : int ) -> tuple[int, int]: UpperCAmelCase : int = x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den UpperCAmelCase : int = x_den * y_den * z_den UpperCAmelCase : int = gcd(_lowerCAmelCase , _lowerCAmelCase ) top //= hcf bottom //= hcf return top, bottom def snake_case_ ( _lowerCAmelCase : int = 35 ) -> int: UpperCAmelCase : set = set() UpperCAmelCase : int UpperCAmelCase : Fraction = Fraction(0 ) UpperCAmelCase : tuple[int, int] for x_num in range(1 , order + 1 ): for x_den in range(x_num + 1 , order + 1 ): for y_num in range(1 , order + 1 ): for y_den in range(y_num + 1 , order + 1 ): # n=1 UpperCAmelCase : Optional[int] = x_num * y_den + x_den * y_num UpperCAmelCase : Tuple = x_den * y_den UpperCAmelCase : Optional[Any] = gcd(_lowerCAmelCase , _lowerCAmelCase ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: UpperCAmelCase : Optional[int] = add_three( _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase ) unique_s.add(_lowerCAmelCase ) # n=2 UpperCAmelCase : Optional[int] = ( x_num * x_num * y_den * y_den + x_den * x_den * y_num * y_num ) UpperCAmelCase : Union[str, Any] = x_den * x_den * y_den * y_den if is_sq(_lowerCAmelCase ) and is_sq(_lowerCAmelCase ): UpperCAmelCase : Optional[Any] = int(sqrt(_lowerCAmelCase ) ) UpperCAmelCase : Dict = int(sqrt(_lowerCAmelCase ) ) UpperCAmelCase : Any = gcd(_lowerCAmelCase , _lowerCAmelCase ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: UpperCAmelCase : str = add_three( _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase ) unique_s.add(_lowerCAmelCase ) # n=-1 UpperCAmelCase : List[str] = x_num * y_num UpperCAmelCase : Tuple = x_den * y_num + x_num * y_den UpperCAmelCase : Optional[int] = gcd(_lowerCAmelCase , _lowerCAmelCase ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: UpperCAmelCase : str = add_three( _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase ) unique_s.add(_lowerCAmelCase ) # n=2 UpperCAmelCase : Dict = x_num * x_num * y_num * y_num UpperCAmelCase : Tuple = ( x_den * x_den * y_num * y_num + x_num * x_num * y_den * y_den ) if is_sq(_lowerCAmelCase ) and is_sq(_lowerCAmelCase ): UpperCAmelCase : Any = int(sqrt(_lowerCAmelCase ) ) UpperCAmelCase : Optional[Any] = int(sqrt(_lowerCAmelCase ) ) UpperCAmelCase : Optional[Any] = gcd(_lowerCAmelCase , _lowerCAmelCase ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: UpperCAmelCase : Tuple = add_three( _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase ) unique_s.add(_lowerCAmelCase ) for num, den in unique_s: total += Fraction(_lowerCAmelCase , _lowerCAmelCase ) return total.denominator + total.numerator if __name__ == "__main__": print(F"{solution() = }")

from pathlib import Path from typing import List from transformers import is_torch_available, is_vision_available from transformers.testing_utils import get_tests_dir, is_tool_test from transformers.tools.agent_types import AGENT_TYPE_MAPPING, AgentAudio, AgentImage, AgentText if is_torch_available(): import torch if is_vision_available(): from PIL import Image lowercase__ =['text', 'image', 'audio'] def __UpperCamelCase ( lowerCAmelCase__ : List[str] ): __a : Optional[int] = [] for input_type in input_types: if input_type == "text": inputs.append('''Text input''' ) elif input_type == "image": inputs.append( Image.open(Path(get_tests_dir('''fixtures/tests_samples/COCO''' ) ) / '''000000039769.png''' ).resize((5_1_2, 5_1_2) ) ) elif input_type == "audio": inputs.append(torch.ones(3_0_0_0 ) ) elif isinstance(lowerCAmelCase__ , lowerCAmelCase__ ): inputs.append(create_inputs(lowerCAmelCase__ ) ) else: raise ValueError(f"Invalid type requested: {input_type}" ) return inputs def __UpperCamelCase ( lowerCAmelCase__ : List ): __a : List[str] = [] for output in outputs: if isinstance(lowerCAmelCase__ , (str, AgentText) ): output_types.append('''text''' ) elif isinstance(lowerCAmelCase__ , (Image.Image, AgentImage) ): output_types.append('''image''' ) elif isinstance(lowerCAmelCase__ , (torch.Tensor, AgentAudio) ): output_types.append('''audio''' ) else: raise ValueError(f"Invalid output: {output}" ) return output_types @is_tool_test class UpperCamelCase__ : def lowerCAmelCase (self : Any ): self.assertTrue(hasattr(self.tool , '''inputs''' ) ) self.assertTrue(hasattr(self.tool , '''outputs''' ) ) __a : Any = self.tool.inputs for _input in inputs: if isinstance(_input , snake_case_ ): for __input in _input: self.assertTrue(__input in authorized_types ) else: self.assertTrue(_input in authorized_types ) __a : Optional[int] = self.tool.outputs for _output in outputs: self.assertTrue(_output in authorized_types ) def lowerCAmelCase (self : List[Any] ): __a : Union[str, Any] = create_inputs(self.tool.inputs ) __a : List[Any] = self.tool(*snake_case_ ) # There is a single output if len(self.tool.outputs ) == 1: __a : Tuple = [outputs] self.assertListEqual(output_types(snake_case_ ) , self.tool.outputs ) def lowerCAmelCase (self : List[Any] ): self.assertTrue(hasattr(self.tool , '''description''' ) ) self.assertTrue(hasattr(self.tool , '''default_checkpoint''' ) ) self.assertTrue(self.tool.description.startswith('''This is a tool that''' ) ) def lowerCAmelCase (self : Any ): __a : Any = create_inputs(self.tool.inputs ) __a : Union[str, Any] = self.tool(*snake_case_ ) if not isinstance(snake_case_ , snake_case_ ): __a : Tuple = [outputs] self.assertEqual(len(snake_case_ ) , len(self.tool.outputs ) ) for output, output_type in zip(snake_case_ , self.tool.outputs ): __a : List[Any] = AGENT_TYPE_MAPPING[output_type] self.assertTrue(isinstance(snake_case_ , snake_case_ ) ) def lowerCAmelCase (self : Optional[int] ): __a : Any = create_inputs(self.tool.inputs ) __a : Dict = [] for _input, input_type in zip(snake_case_ , self.tool.inputs ): if isinstance(snake_case_ , snake_case_ ): _inputs.append([AGENT_TYPE_MAPPING[_input_type](_input ) for _input_type in input_type] ) else: _inputs.append(AGENT_TYPE_MAPPING[input_type](_input ) ) # Should not raise an error __a : Optional[Any] = self.tool(*snake_case_ ) if not isinstance(snake_case_ , snake_case_ ): __a : Dict = [outputs] self.assertEqual(len(snake_case_ ) , len(self.tool.outputs ) )

"""simple docstring""" import argparse import json import requests import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import SegformerImageProcessor, SwinConfig, UperNetConfig, UperNetForSemanticSegmentation def lowercase_ ( __UpperCAmelCase ) -> Any: lowerCAmelCase__ : Union[str, Any] = 384 lowerCAmelCase__ : Dict = 7 if "tiny" in model_name: lowerCAmelCase__ : Union[str, Any] = 96 lowerCAmelCase__ : List[Any] = (2, 2, 6, 2) lowerCAmelCase__ : Optional[int] = (3, 6, 12, 24) elif "small" in model_name: lowerCAmelCase__ : str = 96 lowerCAmelCase__ : Optional[int] = (2, 2, 18, 2) lowerCAmelCase__ : Dict = (3, 6, 12, 24) elif "base" in model_name: lowerCAmelCase__ : Dict = 128 lowerCAmelCase__ : int = (2, 2, 18, 2) lowerCAmelCase__ : Dict = (4, 8, 16, 32) lowerCAmelCase__ : Optional[int] = 12 lowerCAmelCase__ : List[Any] = 512 elif "large" in model_name: lowerCAmelCase__ : Tuple = 192 lowerCAmelCase__ : Optional[int] = (2, 2, 18, 2) lowerCAmelCase__ : Tuple = (6, 12, 24, 48) lowerCAmelCase__ : List[str] = 12 lowerCAmelCase__ : int = 768 # set label information lowerCAmelCase__ : str = 150 lowerCAmelCase__ : List[str] = """huggingface/label-files""" lowerCAmelCase__ : int = """ade20k-id2label.json""" lowerCAmelCase__ : Optional[Any] = json.load(open(hf_hub_download(__UpperCAmelCase , __UpperCAmelCase , repo_type="""dataset""" ) , """r""" ) ) lowerCAmelCase__ : List[Any] = {int(__UpperCAmelCase ): v for k, v in idalabel.items()} lowerCAmelCase__ : Tuple = {v: k for k, v in idalabel.items()} lowerCAmelCase__ : Optional[Any] = SwinConfig( embed_dim=__UpperCAmelCase , depths=__UpperCAmelCase , num_heads=__UpperCAmelCase , window_size=__UpperCAmelCase , out_features=["""stage1""", """stage2""", """stage3""", """stage4"""] , ) lowerCAmelCase__ : str = UperNetConfig( backbone_config=__UpperCAmelCase , auxiliary_in_channels=__UpperCAmelCase , num_labels=__UpperCAmelCase , idalabel=__UpperCAmelCase , labelaid=__UpperCAmelCase , ) return config def lowercase_ ( __UpperCAmelCase ) -> str: lowerCAmelCase__ : int = [] # fmt: off # stem rename_keys.append(("""backbone.patch_embed.projection.weight""", """backbone.embeddings.patch_embeddings.projection.weight""") ) rename_keys.append(("""backbone.patch_embed.projection.bias""", """backbone.embeddings.patch_embeddings.projection.bias""") ) rename_keys.append(("""backbone.patch_embed.norm.weight""", """backbone.embeddings.norm.weight""") ) rename_keys.append(("""backbone.patch_embed.norm.bias""", """backbone.embeddings.norm.bias""") ) # stages for i in range(len(config.backbone_config.depths ) ): for j in range(config.backbone_config.depths[i] ): rename_keys.append((f"""backbone.stages.{i}.blocks.{j}.norm1.weight""", f"""backbone.encoder.layers.{i}.blocks.{j}.layernorm_before.weight""") ) rename_keys.append((f"""backbone.stages.{i}.blocks.{j}.norm1.bias""", f"""backbone.encoder.layers.{i}.blocks.{j}.layernorm_before.bias""") ) rename_keys.append((f"""backbone.stages.{i}.blocks.{j}.attn.w_msa.relative_position_bias_table""", f"""backbone.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table""") ) rename_keys.append((f"""backbone.stages.{i}.blocks.{j}.attn.w_msa.relative_position_index""", f"""backbone.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index""") ) rename_keys.append((f"""backbone.stages.{i}.blocks.{j}.attn.w_msa.proj.weight""", f"""backbone.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight""") ) rename_keys.append((f"""backbone.stages.{i}.blocks.{j}.attn.w_msa.proj.bias""", f"""backbone.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias""") ) rename_keys.append((f"""backbone.stages.{i}.blocks.{j}.norm2.weight""", f"""backbone.encoder.layers.{i}.blocks.{j}.layernorm_after.weight""") ) rename_keys.append((f"""backbone.stages.{i}.blocks.{j}.norm2.bias""", f"""backbone.encoder.layers.{i}.blocks.{j}.layernorm_after.bias""") ) rename_keys.append((f"""backbone.stages.{i}.blocks.{j}.ffn.layers.0.0.weight""", f"""backbone.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight""") ) rename_keys.append((f"""backbone.stages.{i}.blocks.{j}.ffn.layers.0.0.bias""", f"""backbone.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias""") ) rename_keys.append((f"""backbone.stages.{i}.blocks.{j}.ffn.layers.1.weight""", f"""backbone.encoder.layers.{i}.blocks.{j}.output.dense.weight""") ) rename_keys.append((f"""backbone.stages.{i}.blocks.{j}.ffn.layers.1.bias""", f"""backbone.encoder.layers.{i}.blocks.{j}.output.dense.bias""") ) if i < 3: rename_keys.append((f"""backbone.stages.{i}.downsample.reduction.weight""", f"""backbone.encoder.layers.{i}.downsample.reduction.weight""") ) rename_keys.append((f"""backbone.stages.{i}.downsample.norm.weight""", f"""backbone.encoder.layers.{i}.downsample.norm.weight""") ) rename_keys.append((f"""backbone.stages.{i}.downsample.norm.bias""", f"""backbone.encoder.layers.{i}.downsample.norm.bias""") ) rename_keys.append((f"""backbone.norm{i}.weight""", f"""backbone.hidden_states_norms.stage{i+1}.weight""") ) rename_keys.append((f"""backbone.norm{i}.bias""", f"""backbone.hidden_states_norms.stage{i+1}.bias""") ) # decode head rename_keys.extend( [ ("""decode_head.conv_seg.weight""", """decode_head.classifier.weight"""), ("""decode_head.conv_seg.bias""", """decode_head.classifier.bias"""), ("""auxiliary_head.conv_seg.weight""", """auxiliary_head.classifier.weight"""), ("""auxiliary_head.conv_seg.bias""", """auxiliary_head.classifier.bias"""), ] ) # fmt: on return rename_keys def lowercase_ ( __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase ) -> Optional[int]: lowerCAmelCase__ : List[Any] = dct.pop(__UpperCAmelCase ) lowerCAmelCase__ : List[str] = val def lowercase_ ( __UpperCAmelCase , __UpperCAmelCase ) -> Tuple: lowerCAmelCase__ : Union[str, Any] = [int(backbone_config.embed_dim * 2**i ) for i in range(len(backbone_config.depths ) )] for i in range(len(backbone_config.depths ) ): lowerCAmelCase__ : int = num_features[i] for j in range(backbone_config.depths[i] ): # fmt: off # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias) lowerCAmelCase__ : Union[str, Any] = state_dict.pop(f"""backbone.stages.{i}.blocks.{j}.attn.w_msa.qkv.weight""" ) lowerCAmelCase__ : Tuple = state_dict.pop(f"""backbone.stages.{i}.blocks.{j}.attn.w_msa.qkv.bias""" ) # next, add query, keys and values (in that order) to the state dict lowerCAmelCase__ : str = in_proj_weight[:dim, :] lowerCAmelCase__ : Dict = in_proj_bias[: dim] lowerCAmelCase__ : Dict = in_proj_weight[ dim : dim * 2, : ] lowerCAmelCase__ : Tuple = in_proj_bias[ dim : dim * 2 ] lowerCAmelCase__ : int = in_proj_weight[ -dim :, : ] lowerCAmelCase__ : Tuple = in_proj_bias[-dim :] # fmt: on def lowercase_ ( __UpperCAmelCase ) -> List[str]: lowerCAmelCase__ : Optional[int] = x.shape lowerCAmelCase__ : Tuple = x.reshape(__UpperCAmelCase , 4 , in_channel // 4 ) lowerCAmelCase__ : List[Any] = x[:, [0, 2, 1, 3], :].transpose(1 , 2 ).reshape(__UpperCAmelCase , __UpperCAmelCase ) return x def lowercase_ ( __UpperCAmelCase ) -> Dict: lowerCAmelCase__ : List[Any] = x.shape lowerCAmelCase__ : List[str] = x.reshape(__UpperCAmelCase , in_channel // 4 , 4 ) lowerCAmelCase__ : Dict = x[:, :, [0, 2, 1, 3]].transpose(1 , 2 ).reshape(__UpperCAmelCase , __UpperCAmelCase ) return x def lowercase_ ( __UpperCAmelCase ) -> int: lowerCAmelCase__ : Tuple = x.shape[0] lowerCAmelCase__ : Any = x.reshape(4 , in_channel // 4 ) lowerCAmelCase__ : List[Any] = x[[0, 2, 1, 3], :].transpose(0 , 1 ).reshape(__UpperCAmelCase ) return x def lowercase_ ( __UpperCAmelCase ) -> List[str]: lowerCAmelCase__ : List[Any] = x.shape[0] lowerCAmelCase__ : Tuple = x.reshape(in_channel // 4 , 4 ) lowerCAmelCase__ : Union[str, Any] = x[:, [0, 2, 1, 3]].transpose(0 , 1 ).reshape(__UpperCAmelCase ) return x def lowercase_ ( __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase ) -> List[str]: lowerCAmelCase__ : int = { """upernet-swin-tiny""": """https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210531_112542-e380ad3e.pth""", """upernet-swin-small""": """https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210526_192015-ee2fff1c.pth""", """upernet-swin-base""": """https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K_20210531_125459-429057bf.pth""", """upernet-swin-large""": """https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_large_patch4_window12_512x512_pretrain_384x384_22K_160k_ade20k/upernet_swin_large_patch4_window12_512x512_pretrain_384x384_22K_160k_ade20k_20220318_091743-9ba68901.pth""", } lowerCAmelCase__ : str = model_name_to_url[model_name] lowerCAmelCase__ : Optional[Any] = torch.hub.load_state_dict_from_url(__UpperCAmelCase , map_location="""cpu""" , file_name=__UpperCAmelCase )[ """state_dict""" ] for name, param in state_dict.items(): print(__UpperCAmelCase , param.shape ) lowerCAmelCase__ : List[Any] = get_upernet_config(__UpperCAmelCase ) lowerCAmelCase__ : Any = UperNetForSemanticSegmentation(__UpperCAmelCase ) model.eval() # replace "bn" => "batch_norm" for key in state_dict.copy().keys(): lowerCAmelCase__ : Tuple = state_dict.pop(__UpperCAmelCase ) if "bn" in key: lowerCAmelCase__ : Optional[Any] = key.replace("""bn""" , """batch_norm""" ) lowerCAmelCase__ : Dict = val # rename keys lowerCAmelCase__ : List[str] = create_rename_keys(__UpperCAmelCase ) for src, dest in rename_keys: rename_key(__UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase ) read_in_q_k_v(__UpperCAmelCase , config.backbone_config ) # fix downsample parameters for key, value in state_dict.items(): if "downsample" in key: if "reduction" in key: lowerCAmelCase__ : int = reverse_correct_unfold_reduction_order(__UpperCAmelCase ) if "norm" in key: lowerCAmelCase__ : int = reverse_correct_unfold_norm_order(__UpperCAmelCase ) model.load_state_dict(__UpperCAmelCase ) # verify on image lowerCAmelCase__ : Any = """https://huggingface.co/datasets/hf-internal-testing/fixtures_ade20k/resolve/main/ADE_val_00000001.jpg""" lowerCAmelCase__ : Optional[int] = Image.open(requests.get(__UpperCAmelCase , stream=__UpperCAmelCase ).raw ).convert("""RGB""" ) lowerCAmelCase__ : Tuple = SegformerImageProcessor() lowerCAmelCase__ : List[Any] = processor(__UpperCAmelCase , return_tensors="""pt""" ).pixel_values with torch.no_grad(): lowerCAmelCase__ : Tuple = model(__UpperCAmelCase ) lowerCAmelCase__ : Tuple = outputs.logits print(logits.shape ) print("""First values of logits:""" , logits[0, 0, :3, :3] ) # assert values if model_name == "upernet-swin-tiny": lowerCAmelCase__ : List[str] = torch.tensor( [[-7.5958, -7.5958, -7.4302], [-7.5958, -7.5958, -7.4302], [-7.4797, -7.4797, -7.3068]] ) elif model_name == "upernet-swin-small": lowerCAmelCase__ : List[str] = torch.tensor( [[-7.1921, -7.1921, -6.9532], [-7.1921, -7.1921, -6.9532], [-7.0908, -7.0908, -6.8534]] ) elif model_name == "upernet-swin-base": lowerCAmelCase__ : List[str] = torch.tensor( [[-6.5851, -6.5851, -6.4330], [-6.5851, -6.5851, -6.4330], [-6.4763, -6.4763, -6.3254]] ) elif model_name == "upernet-swin-large": lowerCAmelCase__ : List[Any] = torch.tensor( [[-7.5297, -7.5297, -7.3802], [-7.5297, -7.5297, -7.3802], [-7.4044, -7.4044, -7.2586]] ) print("""Logits:""" , outputs.logits[0, 0, :3, :3] ) assert torch.allclose(outputs.logits[0, 0, :3, :3] , __UpperCAmelCase , atol=1E-4 ) print("""Looks ok!""" ) if pytorch_dump_folder_path is not None: print(f"""Saving model {model_name} to {pytorch_dump_folder_path}""" ) model.save_pretrained(__UpperCAmelCase ) print(f"""Saving processor to {pytorch_dump_folder_path}""" ) processor.save_pretrained(__UpperCAmelCase ) if push_to_hub: print(f"""Pushing model and processor for {model_name} to hub""" ) model.push_to_hub(f"""openmmlab/{model_name}""" ) processor.push_to_hub(f"""openmmlab/{model_name}""" ) if __name__ == "__main__": _A = argparse.ArgumentParser() # Required parameters parser.add_argument( """--model_name""", default="""upernet-swin-tiny""", type=str, choices=[f"""upernet-swin-{size}""" for size in ["""tiny""", """small""", """base""", """large"""]], help="""Name of the Swin + UperNet model you'd like to convert.""", ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory.""" ) parser.add_argument( """--push_to_hub""", action="""store_true""", help="""Whether or not to push the converted model to the 🤗 hub.""" ) _A = parser.parse_args() convert_upernet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)

"""simple docstring""" import shutil import tempfile import unittest from transformers import ( SPIECE_UNDERLINE, AddedToken, BatchEncoding, NllbTokenizer, NllbTokenizerFast, is_torch_available, ) from transformers.testing_utils import ( get_tests_dir, nested_simplify, require_sentencepiece, require_tokenizers, require_torch, ) from ...test_tokenization_common import TokenizerTesterMixin _A = get_tests_dir("""fixtures/test_sentencepiece.model""") if is_torch_available(): from transformers.models.mam_aaa.modeling_mam_aaa import shift_tokens_right _A = 2_5_6_0_4_7 _A = 2_5_6_1_4_5 @require_sentencepiece @require_tokenizers class _lowerCamelCase ( a_ , unittest.TestCase ): _lowerCamelCase :Any = NllbTokenizer _lowerCamelCase :Dict = NllbTokenizerFast _lowerCamelCase :str = True _lowerCamelCase :Optional[Any] = True _lowerCamelCase :Union[str, Any] = {} def _lowerCAmelCase ( self : List[str] ) -> int: """simple docstring""" super().setUp() # We have a SentencePiece fixture for testing lowerCAmelCase__ : Optional[int] = NllbTokenizer(UpperCamelCase , keep_accents=UpperCamelCase ) tokenizer.save_pretrained(self.tmpdirname ) def _lowerCAmelCase ( self : Optional[Any] ) -> List[Any]: """simple docstring""" lowerCAmelCase__ : Dict = NllbTokenizer(UpperCamelCase , keep_accents=UpperCamelCase ) lowerCAmelCase__ : List[str] = tokenizer.tokenize("""This is a test""" ) self.assertListEqual(UpperCamelCase , ["""▁This""", """▁is""", """▁a""", """▁t""", """est"""] ) self.assertListEqual( tokenizer.convert_tokens_to_ids(UpperCamelCase ) , [value + tokenizer.fairseq_offset for value in [2_85, 46, 10, 1_70, 3_82]] , ) lowerCAmelCase__ : Dict = tokenizer.tokenize("""I was born in 92000, and this is falsé.""" ) self.assertListEqual( UpperCamelCase , [ SPIECE_UNDERLINE + """I""", SPIECE_UNDERLINE + """was""", SPIECE_UNDERLINE + """b""", """or""", """n""", SPIECE_UNDERLINE + """in""", SPIECE_UNDERLINE + """""", """9""", """2""", """0""", """0""", """0""", """,""", SPIECE_UNDERLINE + """and""", SPIECE_UNDERLINE + """this""", SPIECE_UNDERLINE + """is""", SPIECE_UNDERLINE + """f""", """al""", """s""", """é""", """.""", ] , ) lowerCAmelCase__ : Optional[Any] = tokenizer.convert_tokens_to_ids(UpperCamelCase ) self.assertListEqual( UpperCamelCase , [ value + tokenizer.fairseq_offset for value in [8, 21, 84, 55, 24, 19, 7, 2, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 2, 4] ] , ) lowerCAmelCase__ : List[str] = tokenizer.convert_ids_to_tokens(UpperCamelCase ) self.assertListEqual( UpperCamelCase , [ SPIECE_UNDERLINE + """I""", SPIECE_UNDERLINE + """was""", SPIECE_UNDERLINE + """b""", """or""", """n""", SPIECE_UNDERLINE + """in""", SPIECE_UNDERLINE + """""", """<unk>""", """2""", """0""", """0""", """0""", """,""", SPIECE_UNDERLINE + """and""", SPIECE_UNDERLINE + """this""", SPIECE_UNDERLINE + """is""", SPIECE_UNDERLINE + """f""", """al""", """s""", """<unk>""", """.""", ] , ) def _lowerCAmelCase ( self : Any ) -> Any: """simple docstring""" lowerCAmelCase__ : str = (self.rust_tokenizer_class, """hf-internal-testing/tiny-random-nllb""", {}) for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})""" ): lowerCAmelCase__ : Union[str, Any] = self.rust_tokenizer_class.from_pretrained(UpperCamelCase , **UpperCamelCase ) lowerCAmelCase__ : str = self.tokenizer_class.from_pretrained(UpperCamelCase , **UpperCamelCase ) lowerCAmelCase__ : int = tempfile.mkdtemp() lowerCAmelCase__ : Tuple = tokenizer_r.save_pretrained(UpperCamelCase ) lowerCAmelCase__ : Optional[int] = tokenizer_p.save_pretrained(UpperCamelCase ) # Checks it save with the same files + the tokenizer.json file for the fast one self.assertTrue(any("""tokenizer.json""" in f for f in tokenizer_r_files ) ) lowerCAmelCase__ : Dict = tuple(f for f in tokenizer_r_files if """tokenizer.json""" not in f ) self.assertSequenceEqual(UpperCamelCase , UpperCamelCase ) # Checks everything loads correctly in the same way lowerCAmelCase__ : int = tokenizer_r.from_pretrained(UpperCamelCase ) lowerCAmelCase__ : Union[str, Any] = tokenizer_p.from_pretrained(UpperCamelCase ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(UpperCamelCase , UpperCamelCase ) ) shutil.rmtree(UpperCamelCase ) # Save tokenizer rust, legacy_format=True lowerCAmelCase__ : List[str] = tempfile.mkdtemp() lowerCAmelCase__ : Optional[Any] = tokenizer_r.save_pretrained(UpperCamelCase , legacy_format=UpperCamelCase ) lowerCAmelCase__ : List[str] = tokenizer_p.save_pretrained(UpperCamelCase ) # Checks it save with the same files self.assertSequenceEqual(UpperCamelCase , UpperCamelCase ) # Checks everything loads correctly in the same way lowerCAmelCase__ : List[str] = tokenizer_r.from_pretrained(UpperCamelCase ) lowerCAmelCase__ : Optional[Any] = tokenizer_p.from_pretrained(UpperCamelCase ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(UpperCamelCase , UpperCamelCase ) ) shutil.rmtree(UpperCamelCase ) # Save tokenizer rust, legacy_format=False lowerCAmelCase__ : List[Any] = tempfile.mkdtemp() lowerCAmelCase__ : int = tokenizer_r.save_pretrained(UpperCamelCase , legacy_format=UpperCamelCase ) lowerCAmelCase__ : str = tokenizer_p.save_pretrained(UpperCamelCase ) # Checks it saved the tokenizer.json file self.assertTrue(any("""tokenizer.json""" in f for f in tokenizer_r_files ) ) # Checks everything loads correctly in the same way lowerCAmelCase__ : Dict = tokenizer_r.from_pretrained(UpperCamelCase ) lowerCAmelCase__ : Optional[int] = tokenizer_p.from_pretrained(UpperCamelCase ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(UpperCamelCase , UpperCamelCase ) ) shutil.rmtree(UpperCamelCase ) @require_torch def _lowerCAmelCase ( self : Tuple ) -> List[str]: """simple docstring""" if not self.test_seqaseq: return lowerCAmelCase__ : int = self.get_tokenizers() for tokenizer in tokenizers: with self.subTest(f"""{tokenizer.__class__.__name__}""" ): # Longer text that will definitely require truncation. lowerCAmelCase__ : Any = [ """ UN Chief Says There Is No Military Solution in Syria""", """ Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for""" """ Syria is that 'there is no military solution' to the nearly five-year conflict and more weapons""" """ will only worsen the violence and misery for millions of people.""", ] lowerCAmelCase__ : Optional[int] = [ """Şeful ONU declară că nu există o soluţie militară în Siria""", """Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al""" """ Rusiei pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi""" """ că noi arme nu vor face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.""", ] try: lowerCAmelCase__ : Dict = tokenizer.prepare_seqaseq_batch( src_texts=UpperCamelCase , tgt_texts=UpperCamelCase , max_length=3 , max_target_length=10 , return_tensors="""pt""" , src_lang="""eng_Latn""" , tgt_lang="""ron_Latn""" , ) except NotImplementedError: return self.assertEqual(batch.input_ids.shape[1] , 3 ) self.assertEqual(batch.labels.shape[1] , 10 ) # max_target_length will default to max_length if not specified lowerCAmelCase__ : str = tokenizer.prepare_seqaseq_batch( UpperCamelCase , tgt_texts=UpperCamelCase , max_length=3 , return_tensors="""pt""" ) self.assertEqual(batch.input_ids.shape[1] , 3 ) self.assertEqual(batch.labels.shape[1] , 3 ) lowerCAmelCase__ : int = tokenizer.prepare_seqaseq_batch( src_texts=UpperCamelCase , max_length=3 , max_target_length=10 , return_tensors="""pt""" ) self.assertEqual(batch_encoder_only.input_ids.shape[1] , 3 ) self.assertEqual(batch_encoder_only.attention_mask.shape[1] , 3 ) self.assertNotIn("""decoder_input_ids""" , UpperCamelCase ) @unittest.skip("""Unfortunately way too slow to build a BPE with SentencePiece.""" ) def _lowerCAmelCase ( self : List[str] ) -> Dict: """simple docstring""" pass def _lowerCAmelCase ( self : str ) -> Union[str, Any]: """simple docstring""" for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})""" ): lowerCAmelCase__ : str = [AddedToken("""<special>""" , lstrip=UpperCamelCase )] lowerCAmelCase__ : Optional[Any] = self.rust_tokenizer_class.from_pretrained( UpperCamelCase , additional_special_tokens=UpperCamelCase , **UpperCamelCase ) lowerCAmelCase__ : Dict = tokenizer_r.encode("""Hey this is a <special> token""" ) lowerCAmelCase__ : Dict = tokenizer_r.encode("""<special>""" , add_special_tokens=UpperCamelCase )[0] self.assertTrue(special_token_id in r_output ) if self.test_slow_tokenizer: lowerCAmelCase__ : List[Any] = self.rust_tokenizer_class.from_pretrained( UpperCamelCase , additional_special_tokens=UpperCamelCase , **UpperCamelCase , ) lowerCAmelCase__ : Dict = self.tokenizer_class.from_pretrained( UpperCamelCase , additional_special_tokens=UpperCamelCase , **UpperCamelCase ) lowerCAmelCase__ : Optional[int] = tokenizer_p.encode("""Hey this is a <special> token""" ) lowerCAmelCase__ : Dict = tokenizer_cr.encode("""Hey this is a <special> token""" ) self.assertEqual(UpperCamelCase , UpperCamelCase ) self.assertEqual(UpperCamelCase , UpperCamelCase ) self.assertTrue(special_token_id in p_output ) self.assertTrue(special_token_id in cr_output ) @require_torch @require_sentencepiece @require_tokenizers class _lowerCamelCase ( unittest.TestCase ): _lowerCamelCase :int = "facebook/nllb-200-distilled-600M" _lowerCamelCase :List[str] = [ " UN Chief Says There Is No Military Solution in Syria", " Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.", ] _lowerCamelCase :Optional[Any] = [ "Şeful ONU declară că nu există o soluţie militară în Siria", "Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei" " pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor" " face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.", ] _lowerCamelCase :Tuple = [ 256047, 16297, 134408, 8165, 248066, 14734, 950, 1135, 105721, 3573, 83, 27352, 108, 49486, 2, ] @classmethod def _lowerCAmelCase ( cls : Optional[Any] ) -> Any: """simple docstring""" lowerCAmelCase__ : NllbTokenizer = NllbTokenizer.from_pretrained( cls.checkpoint_name , src_lang="""eng_Latn""" , tgt_lang="""ron_Latn""" ) lowerCAmelCase__ : Optional[Any] = 1 return cls def _lowerCAmelCase ( self : Any ) -> int: """simple docstring""" self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ace_Arab"""] , 25_60_01 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ace_Latn"""] , 25_60_02 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""fra_Latn"""] , 25_60_57 ) def _lowerCAmelCase ( self : List[str] ) -> Optional[Any]: """simple docstring""" lowerCAmelCase__ : Union[str, Any] = self.tokenizer.batch_encode_plus(self.src_text ).input_ids[0] self.assertListEqual(self.expected_src_tokens , UpperCamelCase ) def _lowerCAmelCase ( self : Optional[Any] ) -> Optional[int]: """simple docstring""" self.assertIn(UpperCamelCase , self.tokenizer.all_special_ids ) # fmt: off lowerCAmelCase__ : str = [RO_CODE, 42_54, 9_80_68, 11_29_23, 3_90_72, 39_09, 7_13, 10_27_67, 26, 1_73_14, 3_56_42, 1_46_83, 3_31_18, 20_22, 6_69_87, 2, 25_60_47] # fmt: on lowerCAmelCase__ : Any = self.tokenizer.decode(UpperCamelCase , skip_special_tokens=UpperCamelCase ) lowerCAmelCase__ : Tuple = self.tokenizer.decode(generated_ids[1:] , skip_special_tokens=UpperCamelCase ) self.assertEqual(UpperCamelCase , UpperCamelCase ) self.assertNotIn(self.tokenizer.eos_token , UpperCamelCase ) def _lowerCAmelCase ( self : Optional[int] ) -> List[str]: """simple docstring""" lowerCAmelCase__ : List[Any] = ["""this is gunna be a long sentence """ * 20] assert isinstance(src_text[0] , UpperCamelCase ) lowerCAmelCase__ : int = 10 lowerCAmelCase__ : Any = self.tokenizer(UpperCamelCase , max_length=UpperCamelCase , truncation=UpperCamelCase ).input_ids[0] self.assertEqual(ids[-1] , 2 ) self.assertEqual(ids[0] , UpperCamelCase ) self.assertEqual(len(UpperCamelCase ) , UpperCamelCase ) def _lowerCAmelCase ( self : Any ) -> Any: """simple docstring""" self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["""<mask>""", """ar_AR"""] ) , [25_62_03, 3] ) def _lowerCAmelCase ( self : Optional[Any] ) -> Optional[Any]: """simple docstring""" lowerCAmelCase__ : List[Any] = tempfile.mkdtemp() lowerCAmelCase__ : int = self.tokenizer.fairseq_tokens_to_ids self.tokenizer.save_pretrained(UpperCamelCase ) lowerCAmelCase__ : Union[str, Any] = NllbTokenizer.from_pretrained(UpperCamelCase ) self.assertDictEqual(new_tok.fairseq_tokens_to_ids , UpperCamelCase ) @require_torch def _lowerCAmelCase ( self : int ) -> List[str]: """simple docstring""" lowerCAmelCase__ : Optional[int] = self.tokenizer( self.src_text , text_target=self.tgt_text , padding=UpperCamelCase , truncation=UpperCamelCase , max_length=len(self.expected_src_tokens ) , return_tensors="""pt""" , ) lowerCAmelCase__ : int = shift_tokens_right( batch["""labels"""] , self.tokenizer.pad_token_id , self.tokenizer.lang_code_to_id["""ron_Latn"""] ) self.assertIsInstance(UpperCamelCase , UpperCamelCase ) self.assertEqual((2, 15) , batch.input_ids.shape ) self.assertEqual((2, 15) , batch.attention_mask.shape ) lowerCAmelCase__ : Dict = batch.input_ids.tolist()[0] self.assertListEqual(self.expected_src_tokens , UpperCamelCase ) self.assertEqual(UpperCamelCase , batch.decoder_input_ids[0, 0] ) # EOS # Test that special tokens are reset self.assertEqual(self.tokenizer.prefix_tokens , [EN_CODE] ) self.assertEqual(self.tokenizer.suffix_tokens , [self.tokenizer.eos_token_id] ) def _lowerCAmelCase ( self : Optional[int] ) -> int: """simple docstring""" lowerCAmelCase__ : str = self.tokenizer(self.src_text , padding=UpperCamelCase , truncation=UpperCamelCase , max_length=3 , return_tensors="""pt""" ) lowerCAmelCase__ : Any = self.tokenizer( text_target=self.tgt_text , padding=UpperCamelCase , truncation=UpperCamelCase , max_length=10 , return_tensors="""pt""" ) lowerCAmelCase__ : str = targets["""input_ids"""] lowerCAmelCase__ : Any = shift_tokens_right( UpperCamelCase , self.tokenizer.pad_token_id , decoder_start_token_id=self.tokenizer.lang_code_to_id[self.tokenizer.tgt_lang] , ) self.assertEqual(batch.input_ids.shape[1] , 3 ) self.assertEqual(batch.decoder_input_ids.shape[1] , 10 ) @require_torch def _lowerCAmelCase ( self : Dict ) -> Optional[Any]: """simple docstring""" lowerCAmelCase__ : Any = self.tokenizer._build_translation_inputs( """A test""" , return_tensors="""pt""" , src_lang="""eng_Latn""" , tgt_lang="""fra_Latn""" ) self.assertEqual( nested_simplify(UpperCamelCase ) , { # A, test, EOS, en_XX """input_ids""": [[25_60_47, 70, 73_56, 2]], """attention_mask""": [[1, 1, 1, 1]], # ar_AR """forced_bos_token_id""": 25_60_57, } , ) @require_torch def _lowerCAmelCase ( self : Dict ) -> Tuple: """simple docstring""" lowerCAmelCase__ : Union[str, Any] = True lowerCAmelCase__ : str = self.tokenizer( """UN Chief says there is no military solution in Syria""" , src_lang="""eng_Latn""" , tgt_lang="""fra_Latn""" ) self.assertEqual( inputs.input_ids , [1_62_97, 13_44_08, 2_56_53, 63_70, 2_48, 2_54, 10_39_29, 9_49_95, 1_08, 4_94_86, 2, 25_60_47] ) lowerCAmelCase__ : List[str] = False lowerCAmelCase__ : Union[str, Any] = self.tokenizer( """UN Chief says there is no military solution in Syria""" , src_lang="""eng_Latn""" , tgt_lang="""fra_Latn""" ) self.assertEqual( inputs.input_ids , [25_60_47, 1_62_97, 13_44_08, 2_56_53, 63_70, 2_48, 2_54, 10_39_29, 9_49_95, 1_08, 4_94_86, 2] )

from cva import destroyAllWindows, imread, imshow, waitKey def _UpperCamelCase ( lowercase__ ): # getting number of pixels in the image __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE : Dict = img.shape[0], img.shape[1] # converting each pixel's color to its negative for i in range(lowercase__ ): for j in range(lowercase__ ): __SCREAMING_SNAKE_CASE : int = [255, 255, 255] - img[i][j] return img if __name__ == "__main__": # read original image __lowerCAmelCase : Optional[Any] =imread('image_data/lena.jpg', 1) # convert to its negative __lowerCAmelCase : Union[str, Any] =convert_to_negative(img) # show result image imshow('negative of original image', img) waitKey(0) destroyAllWindows()

'''simple docstring''' from math import sqrt import numpy as np from sympy import symbols # Coefficient # Speed of light (m/s) _A : List[Any] = 299792458 # Symbols _A , _A , _A , _A : Union[str, Any] = symbols('''ct x y z''') def UpperCamelCase_ ( snake_case_ : float ) -> float: '''simple docstring''' if velocity > c: raise ValueError("""Speed must not exceed light speed 299,792,458 [m/s]!""" ) elif velocity < 1: # Usually the speed should be much higher than 1 (c order of magnitude) raise ValueError("""Speed must be greater than or equal to 1!""" ) return velocity / c def UpperCamelCase_ ( snake_case_ : float ) -> float: '''simple docstring''' return 1 / sqrt(1 - beta(snake_case_ ) ** 2 ) def UpperCamelCase_ ( snake_case_ : float ) -> np.ndarray: '''simple docstring''' return np.array( [ [gamma(snake_case_ ), -gamma(snake_case_ ) * beta(snake_case_ ), 0, 0], [-gamma(snake_case_ ) * beta(snake_case_ ), gamma(snake_case_ ), 0, 0], [0, 0, 1, 0], [0, 0, 0, 1], ] ) def UpperCamelCase_ ( snake_case_ : float , snake_case_ : np.ndarray | None = None ) -> np.ndarray: '''simple docstring''' if event is None: __lowerCAmelCase = np.array([ct, x, y, z] ) # Symbolic four vector else: event[0] *= c # x0 is ct (speed of light * time) return transformation_matrix(snake_case_ ) @ event if __name__ == "__main__": import doctest doctest.testmod() # Example of symbolic vector: _A : str = transform(29979245) print('''Example of four vector: ''') print(f'ct\' = {four_vector[0]}') print(f'x\' = {four_vector[1]}') print(f'y\' = {four_vector[2]}') print(f'z\' = {four_vector[3]}') # Substitute symbols with numerical values _A : int = {ct: c, x: 1, y: 1, z: 1} _A : Any = [four_vector[i].subs(sub_dict) for i in range(4)] print(f'\n{numerical_vector}')

'''simple docstring''' import argparse import os from accelerate.utils import ComputeEnvironment from .cluster import get_cluster_input from .config_args import cache_dir, default_config_file, default_yaml_config_file, load_config_from_file # noqa: F401 from .config_utils import _ask_field, _ask_options, _convert_compute_environment # noqa: F401 from .sagemaker import get_sagemaker_input lowercase__ : List[Any] = '''Launches a series of prompts to create and save a `default_config.yaml` configuration file for your training system. Should always be ran first on your machine''' def _lowerCAmelCase ( ) -> Dict: __A : Union[str, Any] = _ask_options( 'In which compute environment are you running?' , ['This machine', 'AWS (Amazon SageMaker)'] , _convert_compute_environment , ) if compute_environment == ComputeEnvironment.AMAZON_SAGEMAKER: __A : str = get_sagemaker_input() else: __A : Union[str, Any] = get_cluster_input() return config def _lowerCAmelCase ( __snake_case : List[str]=None ) -> Dict: if subparsers is not None: __A : Tuple = subparsers.add_parser('config' , description=__snake_case ) else: __A : str = argparse.ArgumentParser('Accelerate config command' , description=__snake_case ) parser.add_argument( '--config_file' , default=__snake_case , help=( 'The path to use to store the config file. Will default to a file named default_config.yaml in the cache ' 'location, which is the content of the environment `HF_HOME` suffixed with \'accelerate\', or if you don\'t have ' 'such an environment variable, your cache directory (\'~/.cache\' or the content of `XDG_CACHE_HOME`) suffixed ' 'with \'huggingface\'.' ) , ) if subparsers is not None: parser.set_defaults(func=__snake_case ) return parser def _lowerCAmelCase ( __snake_case : List[str] ) -> List[str]: __A : Optional[int] = get_user_input() if args.config_file is not None: __A : Dict = args.config_file else: if not os.path.isdir(__snake_case ): os.makedirs(__snake_case ) __A : Any = default_yaml_config_file if config_file.endswith('.json' ): config.to_json_file(__snake_case ) else: config.to_yaml_file(__snake_case ) print(f'accelerate configuration saved at {config_file}' ) def _lowerCAmelCase ( ) -> int: __A : Optional[Any] = config_command_parser() __A : Any = parser.parse_args() config_command(__snake_case ) if __name__ == "__main__": main()

'''simple docstring''' lowercase__ : Any = {'''a''': ['''c''', '''b'''], '''b''': ['''d''', '''e'''], '''c''': [], '''d''': [], '''e''': []} lowercase__ : List[Any] = ['''a''', '''b''', '''c''', '''d''', '''e'''] def _lowerCAmelCase ( __snake_case : str , __snake_case : Tuple , __snake_case : int ) -> Tuple: __A : List[str] = start # add current to visited visited.append(__snake_case ) __A : Optional[int] = edges[current] for neighbor in neighbors: # if neighbor not in visited, visit if neighbor not in visited: __A : int = topological_sort(__snake_case , __snake_case , __snake_case ) # if all neighbors visited add current to sort sort.append(__snake_case ) # if all vertices haven't been visited select a new one to visit if len(__snake_case ) != len(__snake_case ): for vertice in vertices: if vertice not in visited: __A : Dict = topological_sort(__snake_case , __snake_case , __snake_case ) # return sort return sort if __name__ == "__main__": lowercase__ : Tuple = topological_sort('''a''', [], []) print(sort)

import os from typing import Any, Callable, Dict, List, Optional, Tuple, Union import torch from torch import nn from ...models.controlnet import ControlNetModel, ControlNetOutput from ...models.modeling_utils import ModelMixin from ...utils import logging _lowerCamelCase : List[str] = logging.get_logger(__name__) class SCREAMING_SNAKE_CASE__ ( UpperCAmelCase ): '''simple docstring''' def __init__( self : Dict , lowercase : Union[List[ControlNetModel], Tuple[ControlNetModel]] ): '''simple docstring''' super().__init__() _snake_case = nn.ModuleList(lowercase ) def A ( self : Optional[int] , lowercase : torch.FloatTensor , lowercase : Union[torch.Tensor, float, int] , lowercase : torch.Tensor , lowercase : List[torch.tensor] , lowercase : List[float] , lowercase : Optional[torch.Tensor] = None , lowercase : Optional[torch.Tensor] = None , lowercase : Optional[torch.Tensor] = None , lowercase : Optional[Dict[str, Any]] = None , lowercase : bool = False , lowercase : bool = True , ): '''simple docstring''' for i, (image, scale, controlnet) in enumerate(zip(lowercase , lowercase , self.nets ) ): _snake_case , _snake_case = controlnet( lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , ) # merge samples if i == 0: _snake_case , _snake_case = down_samples, mid_sample else: _snake_case = [ samples_prev + samples_curr for samples_prev, samples_curr in zip(lowercase , lowercase ) ] mid_block_res_sample += mid_sample return down_block_res_samples, mid_block_res_sample def A ( self : Dict , lowercase : Union[str, os.PathLike] , lowercase : bool = True , lowercase : Callable = None , lowercase : bool = False , lowercase : Optional[str] = None , ): '''simple docstring''' _snake_case = 0 _snake_case = save_directory for controlnet in self.nets: controlnet.save_pretrained( lowercase , is_main_process=lowercase , save_function=lowercase , safe_serialization=lowercase , variant=lowercase , ) idx += 1 _snake_case = model_path_to_save + f'''_{idx}''' @classmethod def A ( cls : Any , lowercase : Optional[Union[str, os.PathLike]] , **lowercase : List[str] ): '''simple docstring''' _snake_case = 0 _snake_case = [] # load controlnet and append to list until no controlnet directory exists anymore # first controlnet has to be saved under `./mydirectory/controlnet` to be compliant with `DiffusionPipeline.from_prertained` # second, third, ... controlnets have to be saved under `./mydirectory/controlnet_1`, `./mydirectory/controlnet_2`, ... _snake_case = pretrained_model_path while os.path.isdir(lowercase ): _snake_case = ControlNetModel.from_pretrained(lowercase , **lowercase ) controlnets.append(lowercase ) idx += 1 _snake_case = pretrained_model_path + f'''_{idx}''' logger.info(f'''{len(lowercase )} controlnets loaded from {pretrained_model_path}.''' ) if len(lowercase ) == 0: raise ValueError( f'''No ControlNets found under {os.path.dirname(lowercase )}. Expected at least {pretrained_model_path + '_0'}.''' ) return cls(lowercase )

import unittest from transformers import AutoTokenizer, is_flax_available from transformers.testing_utils import require_flax, require_sentencepiece, require_tokenizers, slow if is_flax_available(): import jax.numpy as jnp from transformers import FlaxXLMRobertaModel @require_sentencepiece @require_tokenizers @require_flax class SCREAMING_SNAKE_CASE__ ( unittest.TestCase ): '''simple docstring''' @slow def A ( self : int ): '''simple docstring''' _snake_case = FlaxXLMRobertaModel.from_pretrained('xlm-roberta-base' ) _snake_case = AutoTokenizer.from_pretrained('xlm-roberta-base' ) _snake_case = 'The dog is cute and lives in the garden house' _snake_case = jnp.array([tokenizer.encode(lowercase )] ) _snake_case = (1, 12, 768) # batch_size, sequence_length, embedding_vector_dim _snake_case = jnp.array( [[-0.0101, 0.1218, -0.0803, 0.0801, 0.1327, 0.0776, -0.1215, 0.2383, 0.3338, 0.3106, 0.0300, 0.0252]] ) _snake_case = model(lowercase )['last_hidden_state'] self.assertEqual(output.shape , lowercase ) # compare the actual values for a slice of last dim self.assertTrue(jnp.allclose(output[:, :, -1] , lowercase , atol=1E-3 ) )

from sympy import diff, lambdify, symbols from sympy.functions import * # noqa: F403 def _lowerCamelCase( lowercase__ , lowercase__ , lowercase__ = "x" , lowercase__ = 1_0**-1_0 , lowercase__ = 1 , ) -> complex: '''simple docstring''' __lowercase= symbols(_A ) __lowercase= lambdify(_A , _A ) __lowercase= lambdify(_A , diff(_A , _A ) ) __lowercase= starting_point while True: if diff_function(_A ) != 0: __lowercase= prev_guess - multiplicity * func(_A ) / diff_function( _A ) else: raise ZeroDivisionError('Could not find root' ) from None # Precision is checked by comparing the difference of consecutive guesses if abs(next_guess - prev_guess ) < precision: return next_guess __lowercase= next_guess # Let's Execute if __name__ == "__main__": # Find root of trigonometric function # Find value of pi print(F'The root of sin(x) = 0 is {newton_raphson("sin(x)", 2)}') # Find root of polynomial # Find fourth Root of 5 print(F'The root of x**4 - 5 = 0 is {newton_raphson("x**4 -5", 0.4 +5J)}') # Find value of e print( '''The root of log(y) - 1 = 0 is ''', F'{newton_raphson("log(y) - 1", 2, variable="y")}', ) # Exponential Roots print( '''The root of exp(x) - 1 = 0 is''', F'{newton_raphson("exp(x) - 1", 1_0, precision=0.0_0_5)}', ) # Find root of cos(x) print(F'The root of cos(x) = 0 is {newton_raphson("cos(x)", 0)}')

import unittest from transformers import XLMConfig, is_torch_available from transformers.testing_utils import require_torch, slow, torch_device from ...generation.test_utils import GenerationTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( XLMForMultipleChoice, XLMForQuestionAnswering, XLMForQuestionAnsweringSimple, XLMForSequenceClassification, XLMForTokenClassification, XLMModel, XLMWithLMHeadModel, ) from transformers.models.xlm.modeling_xlm import XLM_PRETRAINED_MODEL_ARCHIVE_LIST class A : def __init__(self , lowerCAmelCase , lowerCAmelCase=1_3 , lowerCAmelCase=7 , lowerCAmelCase=True , lowerCAmelCase=True , lowerCAmelCase=True , lowerCAmelCase=True , lowerCAmelCase=True , lowerCAmelCase=False , lowerCAmelCase=False , lowerCAmelCase=False , lowerCAmelCase=2 , lowerCAmelCase=9_9 , lowerCAmelCase=0 , lowerCAmelCase=3_2 , lowerCAmelCase=5 , lowerCAmelCase=4 , lowerCAmelCase=0.1 , lowerCAmelCase=0.1 , lowerCAmelCase=5_1_2 , lowerCAmelCase=2 , lowerCAmelCase=0.02 , lowerCAmelCase=2 , lowerCAmelCase=4 , lowerCAmelCase="last" , lowerCAmelCase=True , lowerCAmelCase=None , lowerCAmelCase=0 , ): __lowercase= parent __lowercase= batch_size __lowercase= seq_length __lowercase= is_training __lowercase= use_input_lengths __lowercase= use_token_type_ids __lowercase= use_labels __lowercase= gelu_activation __lowercase= sinusoidal_embeddings __lowercase= causal __lowercase= asm __lowercase= n_langs __lowercase= vocab_size __lowercase= n_special __lowercase= hidden_size __lowercase= num_hidden_layers __lowercase= num_attention_heads __lowercase= hidden_dropout_prob __lowercase= attention_probs_dropout_prob __lowercase= max_position_embeddings __lowercase= type_sequence_label_size __lowercase= initializer_range __lowercase= num_labels __lowercase= num_choices __lowercase= summary_type __lowercase= use_proj __lowercase= scope __lowercase= bos_token_id def _A (self ): __lowercase= ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) __lowercase= random_attention_mask([self.batch_size, self.seq_length] ) __lowercase= None if self.use_input_lengths: __lowercase= ( ids_tensor([self.batch_size] , vocab_size=2 ) + self.seq_length - 2 ) # small variation of seq_length __lowercase= None if self.use_token_type_ids: __lowercase= ids_tensor([self.batch_size, self.seq_length] , self.n_langs ) __lowercase= None __lowercase= None __lowercase= None if self.use_labels: __lowercase= ids_tensor([self.batch_size] , self.type_sequence_label_size ) __lowercase= ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) __lowercase= ids_tensor([self.batch_size] , 2 ).float() __lowercase= ids_tensor([self.batch_size] , self.num_choices ) __lowercase= self.get_config() return ( config, input_ids, token_type_ids, input_lengths, sequence_labels, token_labels, is_impossible_labels, choice_labels, input_mask, ) def _A (self ): return XLMConfig( vocab_size=self.vocab_size , n_special=self.n_special , emb_dim=self.hidden_size , n_layers=self.num_hidden_layers , n_heads=self.num_attention_heads , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , gelu_activation=self.gelu_activation , sinusoidal_embeddings=self.sinusoidal_embeddings , asm=self.asm , causal=self.causal , n_langs=self.n_langs , max_position_embeddings=self.max_position_embeddings , initializer_range=self.initializer_range , summary_type=self.summary_type , use_proj=self.use_proj , num_labels=self.num_labels , bos_token_id=self.bos_token_id , ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , ): __lowercase= XLMModel(config=lowerCAmelCase ) model.to(lowerCAmelCase ) model.eval() __lowercase= model(lowerCAmelCase , lengths=lowerCAmelCase , langs=lowerCAmelCase ) __lowercase= model(lowerCAmelCase , langs=lowerCAmelCase ) __lowercase= model(lowerCAmelCase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , ): __lowercase= XLMWithLMHeadModel(lowerCAmelCase ) model.to(lowerCAmelCase ) model.eval() __lowercase= model(lowerCAmelCase , token_type_ids=lowerCAmelCase , labels=lowerCAmelCase ) self.parent.assertEqual(result.loss.shape , () ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , ): __lowercase= XLMForQuestionAnsweringSimple(lowerCAmelCase ) model.to(lowerCAmelCase ) model.eval() __lowercase= model(lowerCAmelCase ) __lowercase= model(lowerCAmelCase , start_positions=lowerCAmelCase , end_positions=lowerCAmelCase ) __lowercase= outputs 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 _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , ): __lowercase= XLMForQuestionAnswering(lowerCAmelCase ) model.to(lowerCAmelCase ) model.eval() __lowercase= model(lowerCAmelCase ) __lowercase= model( lowerCAmelCase , start_positions=lowerCAmelCase , end_positions=lowerCAmelCase , cls_index=lowerCAmelCase , is_impossible=lowerCAmelCase , p_mask=lowerCAmelCase , ) __lowercase= model( lowerCAmelCase , start_positions=lowerCAmelCase , end_positions=lowerCAmelCase , cls_index=lowerCAmelCase , is_impossible=lowerCAmelCase , ) ((__lowercase), )= result_with_labels.to_tuple() __lowercase= model(lowerCAmelCase , start_positions=lowerCAmelCase , end_positions=lowerCAmelCase ) ((__lowercase), )= result_with_labels.to_tuple() self.parent.assertEqual(result_with_labels.loss.shape , () ) self.parent.assertEqual(result.start_top_log_probs.shape , (self.batch_size, model.config.start_n_top) ) self.parent.assertEqual(result.start_top_index.shape , (self.batch_size, model.config.start_n_top) ) self.parent.assertEqual( result.end_top_log_probs.shape , (self.batch_size, model.config.start_n_top * model.config.end_n_top) ) self.parent.assertEqual( result.end_top_index.shape , (self.batch_size, model.config.start_n_top * model.config.end_n_top) ) self.parent.assertEqual(result.cls_logits.shape , (self.batch_size,) ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , ): __lowercase= XLMForSequenceClassification(lowerCAmelCase ) model.to(lowerCAmelCase ) model.eval() __lowercase= model(lowerCAmelCase ) __lowercase= model(lowerCAmelCase , labels=lowerCAmelCase ) self.parent.assertEqual(result.loss.shape , () ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.type_sequence_label_size) ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , ): __lowercase= self.num_labels __lowercase= XLMForTokenClassification(lowerCAmelCase ) model.to(lowerCAmelCase ) model.eval() __lowercase= model(lowerCAmelCase , attention_mask=lowerCAmelCase , labels=lowerCAmelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , ): __lowercase= self.num_choices __lowercase= XLMForMultipleChoice(config=lowerCAmelCase ) model.to(lowerCAmelCase ) model.eval() __lowercase= input_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() __lowercase= token_type_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() __lowercase= input_mask.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() __lowercase= model( lowerCAmelCase , attention_mask=lowerCAmelCase , token_type_ids=lowerCAmelCase , labels=lowerCAmelCase , ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) ) def _A (self ): __lowercase= self.prepare_config_and_inputs() ( ( __lowercase ), ( __lowercase ), ( __lowercase ), ( __lowercase ), ( __lowercase ), ( __lowercase ), ( __lowercase ), ( __lowercase ), ( __lowercase ), )= config_and_inputs __lowercase= {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'lengths': input_lengths} return config, inputs_dict @require_torch class A ( A_ , A_ , A_ , unittest.TestCase ): UpperCamelCase_ : int =( ( XLMModel, XLMWithLMHeadModel, XLMForQuestionAnswering, XLMForSequenceClassification, XLMForQuestionAnsweringSimple, XLMForTokenClassification, XLMForMultipleChoice, ) if is_torch_available() else () ) UpperCamelCase_ : Dict =( (XLMWithLMHeadModel,) if is_torch_available() else () ) # TODO (PVP): Check other models whether language generation is also applicable UpperCamelCase_ : str =( { '''feature-extraction''': XLMModel, '''fill-mask''': XLMWithLMHeadModel, '''question-answering''': XLMForQuestionAnsweringSimple, '''text-classification''': XLMForSequenceClassification, '''text-generation''': XLMWithLMHeadModel, '''token-classification''': XLMForTokenClassification, '''zero-shot''': XLMForSequenceClassification, } if is_torch_available() else {} ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase ): if ( pipeline_test_casse_name == "QAPipelineTests" and tokenizer_name is not None and not tokenizer_name.endswith('Fast' ) ): # `QAPipelineTests` fails for a few models when the slower tokenizer are used. # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework) # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer return True return False def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase=False ): __lowercase= super()._prepare_for_class(lowerCAmelCase , lowerCAmelCase , return_labels=lowerCAmelCase ) if return_labels: if model_class.__name__ == "XLMForQuestionAnswering": __lowercase= torch.zeros( self.model_tester.batch_size , dtype=torch.long , device=lowerCAmelCase ) __lowercase= torch.zeros( self.model_tester.batch_size , dtype=torch.long , device=lowerCAmelCase ) return inputs_dict def _A (self ): __lowercase= XLMModelTester(self ) __lowercase= ConfigTester(self , config_class=lowerCAmelCase , emb_dim=3_7 ) def _A (self ): self.config_tester.run_common_tests() def _A (self ): __lowercase= self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_xlm_model(*lowerCAmelCase ) def _A (self ): __lowercase= self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_xlm_lm_head(*lowerCAmelCase ) def _A (self ): __lowercase= self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_xlm_simple_qa(*lowerCAmelCase ) def _A (self ): __lowercase= self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_xlm_qa(*lowerCAmelCase ) def _A (self ): __lowercase= self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_xlm_sequence_classif(*lowerCAmelCase ) def _A (self ): __lowercase= self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_xlm_token_classif(*lowerCAmelCase ) def _A (self ): __lowercase= self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_xlm_for_multiple_choice(*lowerCAmelCase ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase=False , lowerCAmelCase=1 ): self.assertIsInstance(lowerCAmelCase , lowerCAmelCase ) self.assertListEqual( [isinstance(lowerCAmelCase , lowerCAmelCase ) for iter_attentions in attentions] , [True] * len(lowerCAmelCase ) ) self.assertEqual(len(lowerCAmelCase ) , (max_length - min_length) * num_beam_groups ) for idx, iter_attentions in enumerate(lowerCAmelCase ): # adds PAD dummy token __lowercase= min_length + idx + 1 __lowercase= min_length + idx + 1 __lowercase= ( batch_size * num_beam_groups, config.num_attention_heads, tgt_len, src_len, ) # check attn size self.assertListEqual( [layer_attention.shape for layer_attention in iter_attentions] , [expected_shape] * len(lowerCAmelCase ) ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase=False , lowerCAmelCase=1 ): self.assertIsInstance(lowerCAmelCase , lowerCAmelCase ) self.assertListEqual( [isinstance(lowerCAmelCase , lowerCAmelCase ) for iter_hidden_states in hidden_states] , [True] * len(lowerCAmelCase ) , ) self.assertEqual(len(lowerCAmelCase ) , (max_length - min_length) * num_beam_groups ) for idx, iter_hidden_states in enumerate(lowerCAmelCase ): # adds PAD dummy token __lowercase= min_length + idx + 1 __lowercase= (batch_size * num_beam_groups, seq_len, config.hidden_size) # check hidden size self.assertListEqual( [layer_hidden_states.shape for layer_hidden_states in iter_hidden_states] , [expected_shape] * len(lowerCAmelCase ) , ) pass @slow def _A (self ): for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: __lowercase= XLMModel.from_pretrained(lowerCAmelCase ) self.assertIsNotNone(lowerCAmelCase ) @require_torch class A ( unittest.TestCase ): @slow def _A (self ): __lowercase= XLMWithLMHeadModel.from_pretrained('xlm-mlm-en-2048' ) model.to(lowerCAmelCase ) __lowercase= torch.tensor([[1_4, 4_4_7]] , dtype=torch.long , device=lowerCAmelCase ) # the president __lowercase= [ 1_4, 4_4_7, 1_4, 4_4_7, 1_4, 4_4_7, 1_4, 4_4_7, 1_4, 4_4_7, 1_4, 4_4_7, 1_4, 4_4_7, 1_4, 4_4_7, 1_4, 4_4_7, 1_4, 4_4_7, ] # the president the president the president the president the president the president the president the president the president the president # TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference __lowercase= model.generate(lowerCAmelCase , do_sample=lowerCAmelCase ) self.assertListEqual(output_ids[0].cpu().numpy().tolist() , lowerCAmelCase )

from collections import deque from math import floor from random import random from time import time class lowerCamelCase : '''simple docstring''' def __init__( self ) -> Optional[int]: UpperCAmelCase_ : Dict = {} def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase=1 ) -> List[Any]: if self.graph.get(_UpperCamelCase ): if self.graph[u].count([w, v] ) == 0: self.graph[u].append([w, v] ) else: UpperCAmelCase_ : Optional[int] = [[w, v]] if not self.graph.get(_UpperCamelCase ): UpperCAmelCase_ : int = [] def __UpperCAmelCase ( self ) -> Dict: return list(self.graph ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase ) -> int: if self.graph.get(_UpperCamelCase ): for _ in self.graph[u]: if _[1] == v: self.graph[u].remove(_UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase=-2 , _UpperCamelCase=-1 ) -> Union[str, Any]: if s == d: return [] UpperCAmelCase_ : Optional[Any] = [] UpperCAmelCase_ : Optional[int] = [] if s == -2: UpperCAmelCase_ : Any = list(self.graph )[0] stack.append(_UpperCamelCase ) visited.append(_UpperCamelCase ) UpperCAmelCase_ : Optional[int] = s while True: # check if there is any non isolated nodes if len(self.graph[s] ) != 0: UpperCAmelCase_ : Union[str, Any] = s for node in self.graph[s]: if visited.count(node[1] ) < 1: if node[1] == d: visited.append(_UpperCamelCase ) return visited else: stack.append(node[1] ) visited.append(node[1] ) UpperCAmelCase_ : Tuple = node[1] break # check if all the children are visited if s == ss: stack.pop() if len(_UpperCamelCase ) != 0: UpperCAmelCase_ : Union[str, Any] = stack[len(_UpperCamelCase ) - 1] else: UpperCAmelCase_ : int = ss # check if se have reached the starting point if len(_UpperCamelCase ) == 0: return visited def __UpperCAmelCase ( self , _UpperCamelCase=-1 ) -> Union[str, Any]: if c == -1: UpperCAmelCase_ : Any = floor(random() * 1_0_0_0_0 ) + 1_0 for i in range(_UpperCamelCase ): # every vertex has max 100 edges for _ in range(floor(random() * 1_0_2 ) + 1 ): UpperCAmelCase_ : int = floor(random() * c ) + 1 if n != i: self.add_pair(_UpperCamelCase , _UpperCamelCase , 1 ) def __UpperCAmelCase ( self , _UpperCamelCase=-2 ) -> Tuple: UpperCAmelCase_ : Union[str, Any] = deque() UpperCAmelCase_ : Dict = [] if s == -2: UpperCAmelCase_ : Tuple = list(self.graph )[0] d.append(_UpperCamelCase ) visited.append(_UpperCamelCase ) while d: UpperCAmelCase_ : Any = d.popleft() if len(self.graph[s] ) != 0: for node in self.graph[s]: if visited.count(node[1] ) < 1: d.append(node[1] ) visited.append(node[1] ) return visited def __UpperCAmelCase ( self , _UpperCamelCase ) -> Any: UpperCAmelCase_ : Dict = 0 for x in self.graph: for y in self.graph[x]: if y[1] == u: count += 1 return count def __UpperCAmelCase ( self , _UpperCamelCase ) -> Dict: return len(self.graph[u] ) def __UpperCAmelCase ( self , _UpperCamelCase=-2 ) -> Optional[int]: UpperCAmelCase_ : Tuple = [] UpperCAmelCase_ : List[Any] = [] if s == -2: UpperCAmelCase_ : Optional[Any] = list(self.graph )[0] stack.append(_UpperCamelCase ) visited.append(_UpperCamelCase ) UpperCAmelCase_ : List[str] = s UpperCAmelCase_ : Union[str, Any] = [] while True: # check if there is any non isolated nodes if len(self.graph[s] ) != 0: UpperCAmelCase_ : Tuple = s for node in self.graph[s]: if visited.count(node[1] ) < 1: stack.append(node[1] ) visited.append(node[1] ) UpperCAmelCase_ : Union[str, Any] = node[1] break # check if all the children are visited if s == ss: sorted_nodes.append(stack.pop() ) if len(_UpperCamelCase ) != 0: UpperCAmelCase_ : List[Any] = stack[len(_UpperCamelCase ) - 1] else: UpperCAmelCase_ : Optional[int] = ss # check if se have reached the starting point if len(_UpperCamelCase ) == 0: return sorted_nodes def __UpperCAmelCase ( self ) -> int: UpperCAmelCase_ : List[Any] = [] UpperCAmelCase_ : str = [] UpperCAmelCase_ : Union[str, Any] = list(self.graph )[0] stack.append(_UpperCamelCase ) visited.append(_UpperCamelCase ) UpperCAmelCase_ : Any = -2 UpperCAmelCase_ : List[Any] = [] UpperCAmelCase_ : List[str] = s UpperCAmelCase_ : Optional[int] = False UpperCAmelCase_ : Any = set() while True: # check if there is any non isolated nodes if len(self.graph[s] ) != 0: UpperCAmelCase_ : Union[str, Any] = s for node in self.graph[s]: if ( visited.count(node[1] ) > 0 and node[1] != parent and indirect_parents.count(node[1] ) > 0 and not on_the_way_back ): UpperCAmelCase_ : Dict = len(_UpperCamelCase ) - 1 while len_stack >= 0: if stack[len_stack] == node[1]: anticipating_nodes.add(node[1] ) break else: anticipating_nodes.add(stack[len_stack] ) len_stack -= 1 if visited.count(node[1] ) < 1: stack.append(node[1] ) visited.append(node[1] ) UpperCAmelCase_ : Dict = node[1] break # check if all the children are visited if s == ss: stack.pop() UpperCAmelCase_ : Any = True if len(_UpperCamelCase ) != 0: UpperCAmelCase_ : List[str] = stack[len(_UpperCamelCase ) - 1] else: UpperCAmelCase_ : int = False indirect_parents.append(_UpperCamelCase ) UpperCAmelCase_ : Tuple = s UpperCAmelCase_ : List[Any] = ss # check if se have reached the starting point if len(_UpperCamelCase ) == 0: return list(_UpperCamelCase ) def __UpperCAmelCase ( self ) -> Optional[int]: UpperCAmelCase_ : Union[str, Any] = [] UpperCAmelCase_ : Optional[Any] = [] UpperCAmelCase_ : Any = list(self.graph )[0] stack.append(_UpperCamelCase ) visited.append(_UpperCamelCase ) UpperCAmelCase_ : Tuple = -2 UpperCAmelCase_ : Dict = [] UpperCAmelCase_ : Tuple = s UpperCAmelCase_ : Any = False UpperCAmelCase_ : Dict = set() while True: # check if there is any non isolated nodes if len(self.graph[s] ) != 0: UpperCAmelCase_ : Optional[Any] = s for node in self.graph[s]: if ( visited.count(node[1] ) > 0 and node[1] != parent and indirect_parents.count(node[1] ) > 0 and not on_the_way_back ): UpperCAmelCase_ : int = len(_UpperCamelCase ) - 1 while len_stack_minus_one >= 0: if stack[len_stack_minus_one] == node[1]: anticipating_nodes.add(node[1] ) break else: return True if visited.count(node[1] ) < 1: stack.append(node[1] ) visited.append(node[1] ) UpperCAmelCase_ : Optional[Any] = node[1] break # check if all the children are visited if s == ss: stack.pop() UpperCAmelCase_ : List[Any] = True if len(_UpperCamelCase ) != 0: UpperCAmelCase_ : int = stack[len(_UpperCamelCase ) - 1] else: UpperCAmelCase_ : List[Any] = False indirect_parents.append(_UpperCamelCase ) UpperCAmelCase_ : Union[str, Any] = s UpperCAmelCase_ : Dict = ss # check if se have reached the starting point if len(_UpperCamelCase ) == 0: return False def __UpperCAmelCase ( self , _UpperCamelCase=-2 , _UpperCamelCase=-1 ) -> Tuple: UpperCAmelCase_ : Optional[int] = time() self.dfs(_UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : Optional[int] = time() return end - begin def __UpperCAmelCase ( self , _UpperCamelCase=-2 ) -> int: UpperCAmelCase_ : int = time() self.bfs(_UpperCamelCase ) UpperCAmelCase_ : List[Any] = time() return end - begin class lowerCamelCase : '''simple docstring''' def __init__( self ) -> str: UpperCAmelCase_ : Optional[Any] = {} def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase=1 ) -> Any: # check if the u exists if self.graph.get(_UpperCamelCase ): # if there already is a edge if self.graph[u].count([w, v] ) == 0: self.graph[u].append([w, v] ) else: # if u does not exist UpperCAmelCase_ : List[str] = [[w, v]] # add the other way if self.graph.get(_UpperCamelCase ): # if there already is a edge if self.graph[v].count([w, u] ) == 0: self.graph[v].append([w, u] ) else: # if u does not exist UpperCAmelCase_ : List[str] = [[w, u]] def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase ) -> Union[str, Any]: if self.graph.get(_UpperCamelCase ): for _ in self.graph[u]: if _[1] == v: self.graph[u].remove(_UpperCamelCase ) # the other way round if self.graph.get(_UpperCamelCase ): for _ in self.graph[v]: if _[1] == u: self.graph[v].remove(_UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase=-2 , _UpperCamelCase=-1 ) -> List[str]: if s == d: return [] UpperCAmelCase_ : Union[str, Any] = [] UpperCAmelCase_ : Union[str, Any] = [] if s == -2: UpperCAmelCase_ : Tuple = list(self.graph )[0] stack.append(_UpperCamelCase ) visited.append(_UpperCamelCase ) UpperCAmelCase_ : Dict = s while True: # check if there is any non isolated nodes if len(self.graph[s] ) != 0: UpperCAmelCase_ : Tuple = s for node in self.graph[s]: if visited.count(node[1] ) < 1: if node[1] == d: visited.append(_UpperCamelCase ) return visited else: stack.append(node[1] ) visited.append(node[1] ) UpperCAmelCase_ : Optional[int] = node[1] break # check if all the children are visited if s == ss: stack.pop() if len(_UpperCamelCase ) != 0: UpperCAmelCase_ : Dict = stack[len(_UpperCamelCase ) - 1] else: UpperCAmelCase_ : Dict = ss # check if se have reached the starting point if len(_UpperCamelCase ) == 0: return visited def __UpperCAmelCase ( self , _UpperCamelCase=-1 ) -> Any: if c == -1: UpperCAmelCase_ : List[str] = floor(random() * 1_0_0_0_0 ) + 1_0 for i in range(_UpperCamelCase ): # every vertex has max 100 edges for _ in range(floor(random() * 1_0_2 ) + 1 ): UpperCAmelCase_ : List[Any] = floor(random() * c ) + 1 if n != i: self.add_pair(_UpperCamelCase , _UpperCamelCase , 1 ) def __UpperCAmelCase ( self , _UpperCamelCase=-2 ) -> Optional[Any]: UpperCAmelCase_ : Optional[Any] = deque() UpperCAmelCase_ : List[str] = [] if s == -2: UpperCAmelCase_ : List[str] = list(self.graph )[0] d.append(_UpperCamelCase ) visited.append(_UpperCamelCase ) while d: UpperCAmelCase_ : str = d.popleft() if len(self.graph[s] ) != 0: for node in self.graph[s]: if visited.count(node[1] ) < 1: d.append(node[1] ) visited.append(node[1] ) return visited def __UpperCAmelCase ( self , _UpperCamelCase ) -> Optional[Any]: return len(self.graph[u] ) def __UpperCAmelCase ( self ) -> str: UpperCAmelCase_ : int = [] UpperCAmelCase_ : int = [] UpperCAmelCase_ : str = list(self.graph )[0] stack.append(_UpperCamelCase ) visited.append(_UpperCamelCase ) UpperCAmelCase_ : Optional[int] = -2 UpperCAmelCase_ : Optional[int] = [] UpperCAmelCase_ : List[Any] = s UpperCAmelCase_ : Any = False UpperCAmelCase_ : int = set() while True: # check if there is any non isolated nodes if len(self.graph[s] ) != 0: UpperCAmelCase_ : List[str] = s for node in self.graph[s]: if ( visited.count(node[1] ) > 0 and node[1] != parent and indirect_parents.count(node[1] ) > 0 and not on_the_way_back ): UpperCAmelCase_ : Any = len(_UpperCamelCase ) - 1 while len_stack >= 0: if stack[len_stack] == node[1]: anticipating_nodes.add(node[1] ) break else: anticipating_nodes.add(stack[len_stack] ) len_stack -= 1 if visited.count(node[1] ) < 1: stack.append(node[1] ) visited.append(node[1] ) UpperCAmelCase_ : Optional[int] = node[1] break # check if all the children are visited if s == ss: stack.pop() UpperCAmelCase_ : Optional[int] = True if len(_UpperCamelCase ) != 0: UpperCAmelCase_ : Any = stack[len(_UpperCamelCase ) - 1] else: UpperCAmelCase_ : Optional[Any] = False indirect_parents.append(_UpperCamelCase ) UpperCAmelCase_ : Optional[int] = s UpperCAmelCase_ : Any = ss # check if se have reached the starting point if len(_UpperCamelCase ) == 0: return list(_UpperCamelCase ) def __UpperCAmelCase ( self ) -> List[Any]: UpperCAmelCase_ : List[Any] = [] UpperCAmelCase_ : int = [] UpperCAmelCase_ : List[str] = list(self.graph )[0] stack.append(_UpperCamelCase ) visited.append(_UpperCamelCase ) UpperCAmelCase_ : Optional[Any] = -2 UpperCAmelCase_ : Tuple = [] UpperCAmelCase_ : List[str] = s UpperCAmelCase_ : int = False UpperCAmelCase_ : Union[str, Any] = set() while True: # check if there is any non isolated nodes if len(self.graph[s] ) != 0: UpperCAmelCase_ : str = s for node in self.graph[s]: if ( visited.count(node[1] ) > 0 and node[1] != parent and indirect_parents.count(node[1] ) > 0 and not on_the_way_back ): UpperCAmelCase_ : Any = len(_UpperCamelCase ) - 1 while len_stack_minus_one >= 0: if stack[len_stack_minus_one] == node[1]: anticipating_nodes.add(node[1] ) break else: return True if visited.count(node[1] ) < 1: stack.append(node[1] ) visited.append(node[1] ) UpperCAmelCase_ : Optional[Any] = node[1] break # check if all the children are visited if s == ss: stack.pop() UpperCAmelCase_ : int = True if len(_UpperCamelCase ) != 0: UpperCAmelCase_ : Dict = stack[len(_UpperCamelCase ) - 1] else: UpperCAmelCase_ : Optional[int] = False indirect_parents.append(_UpperCamelCase ) UpperCAmelCase_ : Dict = s UpperCAmelCase_ : Optional[Any] = ss # check if se have reached the starting point if len(_UpperCamelCase ) == 0: return False def __UpperCAmelCase ( self ) -> List[str]: return list(self.graph ) def __UpperCAmelCase ( self , _UpperCamelCase=-2 , _UpperCamelCase=-1 ) -> Any: UpperCAmelCase_ : Optional[int] = time() self.dfs(_UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : Union[str, Any] = time() return end - begin def __UpperCAmelCase ( self , _UpperCamelCase=-2 ) -> Tuple: UpperCAmelCase_ : Optional[Any] = time() self.bfs(_UpperCamelCase ) UpperCAmelCase_ : Optional[int] = time() return end - begin

"""simple docstring""" import os from shutil import copyfile from typing import List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging UpperCAmelCase__ = logging.get_logger(__name__) UpperCAmelCase__ = {'vocab_file': 'sentencepiece.model'} UpperCAmelCase__ = { 'vocab_file': { 'google/rembert': 'https://huggingface.co/google/rembert/resolve/main/sentencepiece.model', }, } UpperCAmelCase__ = { 'google/rembert': 256, } class lowerCAmelCase__ ( A_ ): __a = VOCAB_FILES_NAMES __a = PRETRAINED_VOCAB_FILES_MAP __a = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES def __init__( self : Union[str, Any] , _lowerCamelCase : Any , _lowerCamelCase : Union[str, Any]=False , _lowerCamelCase : Any=True , _lowerCamelCase : Optional[Any]=True , _lowerCamelCase : int="[CLS]" , _lowerCamelCase : Optional[int]="[SEP]" , _lowerCamelCase : Optional[int]="[UNK]" , _lowerCamelCase : Optional[Any]="[SEP]" , _lowerCamelCase : str="[PAD]" , _lowerCamelCase : List[Any]="[CLS]" , _lowerCamelCase : Any="[MASK]" , **_lowerCamelCase : Optional[int] , ): super().__init__( do_lower_case=_lowerCamelCase , remove_space=_lowerCamelCase , keep_accents=_lowerCamelCase , bos_token=_lowerCamelCase , eos_token=_lowerCamelCase , unk_token=_lowerCamelCase , sep_token=_lowerCamelCase , pad_token=_lowerCamelCase , cls_token=_lowerCamelCase , mask_token=_lowerCamelCase , **_lowerCamelCase , ) _snake_case = do_lower_case _snake_case = remove_space _snake_case = keep_accents _snake_case = vocab_file _snake_case = spm.SentencePieceProcessor() self.sp_model.Load(_lowerCamelCase ) @property def lowercase ( self : int ): return len(self.sp_model ) def lowercase ( self : Any ): _snake_case = {self.convert_ids_to_tokens(_lowerCamelCase ): i for i in range(self.vocab_size )} vocab.update(self.added_tokens_encoder ) return vocab def __getstate__( self : List[str] ): _snake_case = self.__dict__.copy() _snake_case = None return state def __setstate__( self : List[str] , _lowerCamelCase : Tuple ): _snake_case = d _snake_case = spm.SentencePieceProcessor() self.sp_model.Load(self.vocab_file ) def lowercase ( self : str , _lowerCamelCase : List[str] , _lowerCamelCase : Tuple=False ): _snake_case = self.sp_model.EncodeAsPieces(_lowerCamelCase ) return pieces def lowercase ( self : str , _lowerCamelCase : str ): return self.sp_model.PieceToId(_lowerCamelCase ) def lowercase ( self : List[str] , _lowerCamelCase : int ): return self.sp_model.IdToPiece(_lowerCamelCase ) def lowercase ( self : Union[str, Any] , _lowerCamelCase : Any ): _snake_case = self.sp_model.decode_pieces(_lowerCamelCase ) return out_string def lowercase ( self : Optional[Any] , _lowerCamelCase : List[int] , _lowerCamelCase : Optional[List[int]] = None ): _snake_case = [self.sep_token_id] _snake_case = [self.cls_token_id] if token_ids_a is None: return cls + token_ids_a + sep return cls + token_ids_a + sep + token_ids_a + sep def lowercase ( self : Tuple , _lowerCamelCase : List[int] , _lowerCamelCase : Optional[List[int]] = None , _lowerCamelCase : bool = False ): if already_has_special_tokens: if token_ids_a is not None: raise ValueError( '''You should not supply a second sequence if the provided sequence of ''' '''ids is already formatted with special tokens for the model.''' ) return [1 if x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a] if token_ids_a is not None: return [1] + ([0] * len(_lowerCamelCase )) + [1] + ([0] * len(_lowerCamelCase )) + [1] return [1] + ([0] * len(_lowerCamelCase )) + [1] def lowercase ( self : Optional[int] , _lowerCamelCase : List[int] , _lowerCamelCase : Optional[List[int]] = None ): _snake_case = [self.sep_token_id] _snake_case = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def lowercase ( self : List[str] , _lowerCamelCase : str , _lowerCamelCase : Optional[str] = None ): if not os.path.isdir(_lowerCamelCase ): logger.error('''Vocabulary path ({}) should be a directory'''.format(_lowerCamelCase ) ) return _snake_case = os.path.join( _lowerCamelCase , (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file'''] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(_lowerCamelCase ): copyfile(self.vocab_file , _lowerCamelCase ) return (out_vocab_file,)

from math import factorial def __UpperCamelCase ( lowerCAmelCase__ : int , lowerCAmelCase__ : int , lowerCAmelCase__ : float ): if successes > trials: raise ValueError('''successes must be lower or equal to trials''' ) if trials < 0 or successes < 0: raise ValueError('''the function is defined for non-negative integers''' ) if not isinstance(lowerCAmelCase__ , lowerCAmelCase__ ) or not isinstance(lowerCAmelCase__ , lowerCAmelCase__ ): raise ValueError('''the function is defined for non-negative integers''' ) if not 0 < prob < 1: raise ValueError('''prob has to be in range of 1 - 0''' ) __a : List[Any] = (prob**successes) * ((1 - prob) ** (trials - successes)) # Calculate the binomial coefficient: n! / k!(n-k)! __a : Optional[Any] = float(factorial(lowerCAmelCase__ ) ) coefficient /= factorial(lowerCAmelCase__ ) * factorial(trials - successes ) return probability * coefficient if __name__ == "__main__": from doctest import testmod testmod() print('Probability of 2 successes out of 4 trails') print('with probability of 0.75 is:', end=' ') print(binomial_distribution(2, 4, 0.75))

import os from pathlib import Path import numpy as np import pytest from pack_dataset import pack_data_dir from parameterized import parameterized from save_len_file import save_len_file from torch.utils.data import DataLoader from transformers import AutoTokenizer from transformers.models.mbart.modeling_mbart import shift_tokens_right from transformers.testing_utils import TestCasePlus, slow from utils import FAIRSEQ_AVAILABLE, DistributedSortishSampler, LegacySeqaSeqDataset, SeqaSeqDataset lowercase__ ='bert-base-cased' lowercase__ ='google/pegasus-xsum' lowercase__ =[' Sam ate lunch today.', 'Sams lunch ingredients.'] lowercase__ =['A very interesting story about what I ate for lunch.', 'Avocado, celery, turkey, coffee'] lowercase__ ='patrickvonplaten/t5-tiny-random' lowercase__ ='sshleifer/bart-tiny-random' lowercase__ ='sshleifer/tiny-mbart' lowercase__ ='sshleifer/tiny-marian-en-de' def __UpperCamelCase ( lowerCAmelCase__ : Path , lowerCAmelCase__ : list ): __a : List[Any] = '''\n'''.join(lowerCAmelCase__ ) Path(lowerCAmelCase__ ).open('''w''' ).writelines(lowerCAmelCase__ ) def __UpperCamelCase ( lowerCAmelCase__ : int ): for split in ["train", "val", "test"]: _dump_articles(os.path.join(lowerCAmelCase__ , f"{split}.source" ) , lowerCAmelCase__ ) _dump_articles(os.path.join(lowerCAmelCase__ , f"{split}.target" ) , lowerCAmelCase__ ) return tmp_dir class UpperCamelCase__ ( __lowercase ): @parameterized.expand( [ MBART_TINY, MARIAN_TINY, T5_TINY, BART_TINY, PEGASUS_XSUM, ] , ) @slow def lowerCAmelCase (self : int , snake_case_ : int ): __a : Optional[Any] = AutoTokenizer.from_pretrained(snake_case_ ) __a : Optional[Any] = make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir() ) __a : Union[str, Any] = max(len(tokenizer.encode(snake_case_ ) ) for a in ARTICLES ) __a : str = max(len(tokenizer.encode(snake_case_ ) ) for a in SUMMARIES ) __a : str = 4 __a : Dict = 8 assert max_len_target > max_src_len # Will be truncated assert max_len_source > max_src_len # Will be truncated __a , __a : Any = '''ro_RO''', '''de_DE''' # ignored for all but mbart, but never causes error. __a : List[Any] = SeqaSeqDataset( snake_case_ , data_dir=snake_case_ , type_path='''train''' , max_source_length=snake_case_ , max_target_length=snake_case_ , src_lang=snake_case_ , tgt_lang=snake_case_ , ) __a : Dict = DataLoader(snake_case_ , batch_size=2 , collate_fn=train_dataset.collate_fn ) for batch in dataloader: assert isinstance(snake_case_ , snake_case_ ) assert batch["attention_mask"].shape == batch["input_ids"].shape # show that articles were trimmed. assert batch["input_ids"].shape[1] == max_src_len # show that targets are the same len assert batch["labels"].shape[1] == max_tgt_len if tok_name != MBART_TINY: continue # check language codes in correct place __a : Dict = shift_tokens_right(batch['''labels'''] , tokenizer.pad_token_id ) assert batch["decoder_input_ids"][0, 0].item() == tokenizer.lang_code_to_id[tgt_lang] assert batch["decoder_input_ids"][0, -1].item() == tokenizer.eos_token_id assert batch["input_ids"][0, -2].item() == tokenizer.eos_token_id assert batch["input_ids"][0, -1].item() == tokenizer.lang_code_to_id[src_lang] break # No need to test every batch @parameterized.expand([BART_TINY, BERT_BASE_CASED] ) def lowerCAmelCase (self : Optional[Any] , snake_case_ : str ): __a : Union[str, Any] = AutoTokenizer.from_pretrained(snake_case_ ) __a : str = make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir() ) __a : Any = max(len(tokenizer.encode(snake_case_ ) ) for a in ARTICLES ) __a : Any = max(len(tokenizer.encode(snake_case_ ) ) for a in SUMMARIES ) __a : Dict = 4 __a : Optional[int] = LegacySeqaSeqDataset( snake_case_ , data_dir=snake_case_ , type_path='''train''' , max_source_length=2_0 , max_target_length=snake_case_ , ) __a : Optional[Any] = DataLoader(snake_case_ , batch_size=2 , collate_fn=train_dataset.collate_fn ) for batch in dataloader: assert batch["attention_mask"].shape == batch["input_ids"].shape # show that articles were trimmed. assert batch["input_ids"].shape[1] == max_len_source assert 2_0 >= batch["input_ids"].shape[1] # trimmed significantly # show that targets were truncated assert batch["labels"].shape[1] == trunc_target # Truncated assert max_len_target > trunc_target # Truncated break # No need to test every batch def lowerCAmelCase (self : List[str] ): __a : int = AutoTokenizer.from_pretrained('''facebook/mbart-large-cc25''' ) __a : Any = Path(make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir() ) ) __a : Optional[int] = tmp_dir.joinpath('''train.source''' ).open().readlines() __a : List[Any] = Path(make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir() ) ) pack_data_dir(snake_case_ , snake_case_ , 1_2_8 , snake_case_ ) __a : Optional[Any] = {x.name for x in tmp_dir.iterdir()} __a : Union[str, Any] = {x.name for x in save_dir.iterdir()} __a : str = save_dir.joinpath('''train.source''' ).open().readlines() # orig: [' Sam ate lunch today.\n', 'Sams lunch ingredients.'] # desired_packed: [' Sam ate lunch today.\n Sams lunch ingredients.'] assert len(snake_case_ ) < len(snake_case_ ) assert len(snake_case_ ) == 1 assert len(packed_examples[0] ) == sum(len(snake_case_ ) for x in orig_examples ) assert orig_paths == new_paths @pytest.mark.skipif(not FAIRSEQ_AVAILABLE , reason='''This test requires fairseq''' ) def lowerCAmelCase (self : Any ): if not FAIRSEQ_AVAILABLE: return __a , __a , __a : Any = self._get_dataset(max_len=6_4 ) __a : int = 6_4 __a : List[str] = ds.make_dynamic_sampler(snake_case_ , required_batch_size_multiple=snake_case_ ) __a : List[str] = [len(snake_case_ ) for x in batch_sampler] assert len(set(snake_case_ ) ) > 1 # it's not dynamic batch size if every batch is the same length assert sum(snake_case_ ) == len(snake_case_ ) # no dropped or added examples __a : Union[str, Any] = DataLoader(snake_case_ , batch_sampler=snake_case_ , collate_fn=ds.collate_fn , num_workers=2 ) __a : Tuple = [] __a : Union[str, Any] = [] for batch in data_loader: __a : Any = batch['''input_ids'''].shape __a : str = src_shape[0] assert bs % required_batch_size_multiple == 0 or bs < required_batch_size_multiple __a : Optional[Any] = np.product(batch['''input_ids'''].shape ) num_src_per_batch.append(snake_case_ ) if num_src_tokens > (max_tokens * 1.1): failures.append(snake_case_ ) assert num_src_per_batch[0] == max(snake_case_ ) if failures: raise AssertionError(f"too many tokens in {len(snake_case_ )} batches" ) def lowerCAmelCase (self : int ): __a , __a , __a : Optional[int] = self._get_dataset(max_len=5_1_2 ) __a : Union[str, Any] = 2 __a : str = ds.make_sortish_sampler(snake_case_ , shuffle=snake_case_ ) __a : Tuple = DataLoader(snake_case_ , batch_size=snake_case_ , collate_fn=ds.collate_fn , num_workers=2 ) __a : Tuple = DataLoader(snake_case_ , batch_size=snake_case_ , collate_fn=ds.collate_fn , num_workers=2 , sampler=snake_case_ ) __a : Optional[int] = tokenizer.pad_token_id def count_pad_tokens(snake_case_ : Union[str, Any] , snake_case_ : List[str]="input_ids" ): return [batch[k].eq(snake_case_ ).sum().item() for batch in data_loader] assert sum(count_pad_tokens(snake_case_ , k='''labels''' ) ) < sum(count_pad_tokens(snake_case_ , k='''labels''' ) ) assert sum(count_pad_tokens(snake_case_ ) ) < sum(count_pad_tokens(snake_case_ ) ) assert len(snake_case_ ) == len(snake_case_ ) def lowerCAmelCase (self : int , snake_case_ : int=1_0_0_0 , snake_case_ : Optional[Any]=1_2_8 ): if os.getenv('''USE_REAL_DATA''' , snake_case_ ): __a : Optional[int] = '''examples/seq2seq/wmt_en_ro''' __a : List[Any] = max_len * 2 * 6_4 if not Path(snake_case_ ).joinpath('''train.len''' ).exists(): save_len_file(snake_case_ , snake_case_ ) else: __a : int = '''examples/seq2seq/test_data/wmt_en_ro''' __a : List[str] = max_len * 4 save_len_file(snake_case_ , snake_case_ ) __a : str = AutoTokenizer.from_pretrained(snake_case_ ) __a : Optional[int] = SeqaSeqDataset( snake_case_ , data_dir=snake_case_ , type_path='''train''' , max_source_length=snake_case_ , max_target_length=snake_case_ , n_obs=snake_case_ , ) return ds, max_tokens, tokenizer def lowerCAmelCase (self : List[str] ): __a , __a , __a : str = self._get_dataset() __a : Optional[Any] = set(DistributedSortishSampler(snake_case_ , 2_5_6 , num_replicas=2 , rank=0 , add_extra_examples=snake_case_ ) ) __a : Tuple = set(DistributedSortishSampler(snake_case_ , 2_5_6 , num_replicas=2 , rank=1 , add_extra_examples=snake_case_ ) ) assert idsa.intersection(snake_case_ ) == set() @parameterized.expand( [ MBART_TINY, MARIAN_TINY, T5_TINY, BART_TINY, PEGASUS_XSUM, ] , ) def lowerCAmelCase (self : str , snake_case_ : Union[str, Any] ): __a : Union[str, Any] = AutoTokenizer.from_pretrained(snake_case_ , use_fast=snake_case_ ) if tok_name == MBART_TINY: __a : Any = SeqaSeqDataset( snake_case_ , data_dir=make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir() ) , type_path='''train''' , max_source_length=4 , max_target_length=8 , src_lang='''EN''' , tgt_lang='''FR''' , ) __a : Tuple = train_dataset.dataset_kwargs assert "src_lang" in kwargs and "tgt_lang" in kwargs else: __a : Optional[Any] = SeqaSeqDataset( snake_case_ , data_dir=make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir() ) , type_path='''train''' , max_source_length=4 , max_target_length=8 , ) __a : List[Any] = train_dataset.dataset_kwargs assert "add_prefix_space" not in kwargs if tok_name != BART_TINY else "add_prefix_space" in kwargs assert len(snake_case_ ) == 1 if tok_name == BART_TINY else len(snake_case_ ) == 0

"""simple docstring""" import itertools import random import unittest import numpy as np from transformers import is_speech_available from transformers.testing_utils import require_torch, require_torchaudio from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin if is_speech_available(): from transformers import SpeechaTextFeatureExtractor lowerCAmelCase__ : int = random.Random() def a_ ( lowerCamelCase , lowerCamelCase=1.0 , lowerCamelCase=None , lowerCamelCase=None ): if rng is None: UpperCAmelCase__ = global_rng UpperCAmelCase__ = [] for batch_idx in range(shape[0] ): values.append([] ) for _ in range(shape[1] ): values[-1].append(rng.random() * scale ) return values @require_torch @require_torchaudio class snake_case ( unittest.TestCase ): """simple docstring""" def __init__( self : Optional[Any] ,lowerCamelCase__ : List[Any] ,lowerCamelCase__ : Optional[Any]=7 ,lowerCamelCase__ : Dict=400 ,lowerCamelCase__ : str=2_000 ,lowerCamelCase__ : int=24 ,lowerCamelCase__ : List[Any]=24 ,lowerCamelCase__ : List[Any]=0.0 ,lowerCamelCase__ : Dict=16_000 ,lowerCamelCase__ : Union[str, Any]=True ,lowerCamelCase__ : Dict=True ,): UpperCAmelCase__ = parent UpperCAmelCase__ = batch_size UpperCAmelCase__ = min_seq_length UpperCAmelCase__ = max_seq_length UpperCAmelCase__ = (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1) UpperCAmelCase__ = feature_size UpperCAmelCase__ = num_mel_bins UpperCAmelCase__ = padding_value UpperCAmelCase__ = sampling_rate UpperCAmelCase__ = return_attention_mask UpperCAmelCase__ = do_normalize def __lowerCAmelCase ( self : List[str] ): return { "feature_size": self.feature_size, "num_mel_bins": self.num_mel_bins, "padding_value": self.padding_value, "sampling_rate": self.sampling_rate, "return_attention_mask": self.return_attention_mask, "do_normalize": self.do_normalize, } def __lowerCAmelCase ( self : List[Any] ,lowerCamelCase__ : Union[str, Any]=False ,lowerCamelCase__ : Optional[int]=False ): def _flatten(lowerCamelCase__ : List[str] ): return list(itertools.chain(*lowerCamelCase__ ) ) if equal_length: UpperCAmelCase__ = [floats_list((self.max_seq_length, self.feature_size) ) for _ in range(self.batch_size )] else: # make sure that inputs increase in size UpperCAmelCase__ = [ floats_list((x, self.feature_size) ) for x in range(self.min_seq_length ,self.max_seq_length ,self.seq_length_diff ) ] if numpify: UpperCAmelCase__ = [np.asarray(lowerCamelCase__ ) for x in speech_inputs] return speech_inputs @require_torch @require_torchaudio class snake_case ( __UpperCAmelCase , unittest.TestCase ): """simple docstring""" snake_case__ = SpeechaTextFeatureExtractor if is_speech_available() else None def __lowerCAmelCase ( self : List[Any] ): UpperCAmelCase__ = SpeechaTextFeatureExtractionTester(self ) def __lowerCAmelCase ( self : Tuple ,lowerCamelCase__ : Dict ): self.assertTrue(np.all(np.mean(lowerCamelCase__ ,axis=0 ) < 1e-3 ) ) self.assertTrue(np.all(np.abs(np.var(lowerCamelCase__ ,axis=0 ) - 1 ) < 1e-3 ) ) def __lowerCAmelCase ( self : int ): # Tests that all call wrap to encode_plus and batch_encode_plus UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() ) # create three inputs of length 800, 1000, and 1200 UpperCAmelCase__ = [floats_list((1, x) )[0] for x in range(800 ,1_400 ,200 )] UpperCAmelCase__ = [np.asarray(lowerCamelCase__ ) for speech_input in speech_inputs] # Test feature size UpperCAmelCase__ = feature_extractor(lowerCamelCase__ ,padding=lowerCamelCase__ ,return_tensors='np' ).input_features self.assertTrue(input_features.ndim == 3 ) self.assertTrue(input_features.shape[-1] == feature_extractor.feature_size ) # Test not batched input UpperCAmelCase__ = feature_extractor(speech_inputs[0] ,return_tensors='np' ).input_features UpperCAmelCase__ = feature_extractor(np_speech_inputs[0] ,return_tensors='np' ).input_features self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ,atol=1e-3 ) ) # Test batched UpperCAmelCase__ = feature_extractor(lowerCamelCase__ ,return_tensors='np' ).input_features UpperCAmelCase__ = feature_extractor(lowerCamelCase__ ,return_tensors='np' ).input_features for enc_seq_a, enc_seq_a in zip(lowerCamelCase__ ,lowerCamelCase__ ): self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ,atol=1e-3 ) ) # Test 2-D numpy arrays are batched. UpperCAmelCase__ = [floats_list((1, x) )[0] for x in (800, 800, 800)] UpperCAmelCase__ = np.asarray(lowerCamelCase__ ) UpperCAmelCase__ = feature_extractor(lowerCamelCase__ ,return_tensors='np' ).input_features UpperCAmelCase__ = feature_extractor(lowerCamelCase__ ,return_tensors='np' ).input_features for enc_seq_a, enc_seq_a in zip(lowerCamelCase__ ,lowerCamelCase__ ): self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ,atol=1e-3 ) ) def __lowerCAmelCase ( self : Optional[Any] ): UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() ) UpperCAmelCase__ = [floats_list((1, x) )[0] for x in range(800 ,1_400 ,200 )] UpperCAmelCase__ = ['longest', 'max_length', 'do_not_pad'] UpperCAmelCase__ = [None, 16, None] for max_length, padding in zip(lowerCamelCase__ ,lowerCamelCase__ ): UpperCAmelCase__ = feature_extractor( lowerCamelCase__ ,padding=lowerCamelCase__ ,max_length=lowerCamelCase__ ,return_attention_mask=lowerCamelCase__ ) UpperCAmelCase__ = inputs.input_features UpperCAmelCase__ = inputs.attention_mask UpperCAmelCase__ = [np.sum(lowerCamelCase__ ) for x in attention_mask] self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]] ) self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]] ) self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]] ) def __lowerCAmelCase ( self : str ): UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() ) UpperCAmelCase__ = [floats_list((1, x) )[0] for x in range(800 ,1_400 ,200 )] UpperCAmelCase__ = ['longest', 'max_length', 'do_not_pad'] UpperCAmelCase__ = [None, 16, None] for max_length, padding in zip(lowerCamelCase__ ,lowerCamelCase__ ): UpperCAmelCase__ = feature_extractor( lowerCamelCase__ ,max_length=lowerCamelCase__ ,padding=lowerCamelCase__ ,return_tensors='np' ,return_attention_mask=lowerCamelCase__ ) UpperCAmelCase__ = inputs.input_features UpperCAmelCase__ = inputs.attention_mask UpperCAmelCase__ = [np.sum(lowerCamelCase__ ) for x in attention_mask] self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]] ) self.assertTrue(input_features[0][fbank_feat_lengths[0] :].sum() < 1e-6 ) self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]] ) self.assertTrue(input_features[0][fbank_feat_lengths[1] :].sum() < 1e-6 ) self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]] ) def __lowerCAmelCase ( self : List[Any] ): UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() ) UpperCAmelCase__ = [floats_list((1, x) )[0] for x in range(800 ,1_400 ,200 )] UpperCAmelCase__ = feature_extractor( lowerCamelCase__ ,padding='max_length' ,max_length=4 ,truncation=lowerCamelCase__ ,return_tensors='np' ,return_attention_mask=lowerCamelCase__ ,) UpperCAmelCase__ = inputs.input_features UpperCAmelCase__ = inputs.attention_mask UpperCAmelCase__ = np.sum(attention_mask == 1 ,axis=1 ) self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]] ) self._check_zero_mean_unit_variance(input_features[1] ) self._check_zero_mean_unit_variance(input_features[2] ) def __lowerCAmelCase ( self : int ): UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() ) UpperCAmelCase__ = [floats_list((1, x) )[0] for x in range(800 ,1_400 ,200 )] UpperCAmelCase__ = feature_extractor( lowerCamelCase__ ,padding='longest' ,max_length=4 ,truncation=lowerCamelCase__ ,return_tensors='np' ,return_attention_mask=lowerCamelCase__ ,) UpperCAmelCase__ = inputs.input_features UpperCAmelCase__ = inputs.attention_mask UpperCAmelCase__ = np.sum(attention_mask == 1 ,axis=1 ) self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]] ) self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]] ) self._check_zero_mean_unit_variance(input_features[2] ) # make sure that if max_length < longest -> then pad to max_length self.assertEqual(input_features.shape ,(3, 4, 24) ) UpperCAmelCase__ = [floats_list((1, x) )[0] for x in range(800 ,1_400 ,200 )] UpperCAmelCase__ = feature_extractor( lowerCamelCase__ ,padding='longest' ,max_length=16 ,truncation=lowerCamelCase__ ,return_tensors='np' ,return_attention_mask=lowerCamelCase__ ,) UpperCAmelCase__ = inputs.input_features UpperCAmelCase__ = inputs.attention_mask UpperCAmelCase__ = np.sum(attention_mask == 1 ,axis=1 ) self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]] ) self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]] ) self._check_zero_mean_unit_variance(input_features[2] ) # make sure that if max_length < longest -> then pad to max_length self.assertEqual(input_features.shape ,(3, 6, 24) ) def __lowerCAmelCase ( self : Optional[Any] ): import torch UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() ) UpperCAmelCase__ = np.random.rand(100 ,32 ).astype(np.floataa ) UpperCAmelCase__ = np_speech_inputs.tolist() for inputs in [py_speech_inputs, np_speech_inputs]: UpperCAmelCase__ = feature_extractor.pad([{'input_features': inputs}] ,return_tensors='np' ) self.assertTrue(np_processed.input_features.dtype == np.floataa ) UpperCAmelCase__ = feature_extractor.pad([{'input_features': inputs}] ,return_tensors='pt' ) self.assertTrue(pt_processed.input_features.dtype == torch.floataa ) def __lowerCAmelCase ( self : List[str] ,lowerCamelCase__ : Tuple ): from datasets import load_dataset UpperCAmelCase__ = load_dataset('hf-internal-testing/librispeech_asr_dummy' ,'clean' ,split='validation' ) # automatic decoding with librispeech UpperCAmelCase__ = ds.sort('id' ).select(range(lowerCamelCase__ ) )[:num_samples]['audio'] return [x["array"] for x in speech_samples] def __lowerCAmelCase ( self : Optional[Any] ): # fmt: off UpperCAmelCase__ = np.array([ -1.5_7_4_5, -1.7_7_1_3, -1.7_0_2_0, -1.6_0_6_9, -1.2_2_5_0, -1.1_1_0_5, -0.9_0_7_2, -0.8_2_4_1, -1.2_3_1_0, -0.8_0_9_8, -0.3_3_2_0, -0.4_1_0_1, -0.7_9_8_5, -0.4_9_9_6, -0.8_2_1_3, -0.9_1_2_8, -1.0_4_2_0, -1.1_2_8_6, -1.0_4_4_0, -0.7_9_9_9, -0.8_4_0_5, -1.2_2_7_5, -1.5_4_4_3, -1.4_6_2_5, ] ) # fmt: on UpperCAmelCase__ = self._load_datasamples(1 ) UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() ) UpperCAmelCase__ = feature_extractor(lowerCamelCase__ ,return_tensors='pt' ).input_features self.assertEquals(input_features.shape ,(1, 584, 24) ) self.assertTrue(np.allclose(input_features[0, 0, :30] ,lowerCamelCase__ ,atol=1e-4 ) )

"""simple docstring""" import os import sys import unittest lowerCAmelCase__ : Tuple = os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))) sys.path.append(os.path.join(git_repo_path, 'utils')) import get_test_info # noqa: E402 from get_test_info import ( # noqa: E402 get_model_to_test_mapping, get_model_to_tester_mapping, get_test_to_tester_mapping, ) lowerCAmelCase__ : Tuple = os.path.join('tests', 'models', 'bert', 'test_modeling_bert.py') lowerCAmelCase__ : Optional[Any] = os.path.join('tests', 'models', 'blip', 'test_modeling_blip.py') class snake_case ( unittest.TestCase ): """simple docstring""" def __lowerCAmelCase ( self : List[str] ): UpperCAmelCase__ = get_test_to_tester_mapping(lowerCamelCase__ ) UpperCAmelCase__ = get_test_to_tester_mapping(lowerCamelCase__ ) UpperCAmelCase__ = {'BertModelTest': 'BertModelTester'} UpperCAmelCase__ = { 'BlipModelTest': 'BlipModelTester', 'BlipTextImageModelTest': 'BlipTextImageModelsModelTester', 'BlipTextModelTest': 'BlipTextModelTester', 'BlipTextRetrievalModelTest': 'BlipTextRetrievalModelTester', 'BlipVQAModelTest': 'BlipVQAModelTester', 'BlipVisionModelTest': 'BlipVisionModelTester', } self.assertEqual(get_test_info.to_json(lowerCamelCase__ ) ,lowerCamelCase__ ) self.assertEqual(get_test_info.to_json(lowerCamelCase__ ) ,lowerCamelCase__ ) def __lowerCAmelCase ( self : Optional[Any] ): UpperCAmelCase__ = get_model_to_test_mapping(lowerCamelCase__ ) UpperCAmelCase__ = get_model_to_test_mapping(lowerCamelCase__ ) UpperCAmelCase__ = { 'BertForMaskedLM': ['BertModelTest'], 'BertForMultipleChoice': ['BertModelTest'], 'BertForNextSentencePrediction': ['BertModelTest'], 'BertForPreTraining': ['BertModelTest'], 'BertForQuestionAnswering': ['BertModelTest'], 'BertForSequenceClassification': ['BertModelTest'], 'BertForTokenClassification': ['BertModelTest'], 'BertLMHeadModel': ['BertModelTest'], 'BertModel': ['BertModelTest'], } UpperCAmelCase__ = { 'BlipForConditionalGeneration': ['BlipTextImageModelTest'], 'BlipForImageTextRetrieval': ['BlipTextRetrievalModelTest'], 'BlipForQuestionAnswering': ['BlipVQAModelTest'], 'BlipModel': ['BlipModelTest'], 'BlipTextModel': ['BlipTextModelTest'], 'BlipVisionModel': ['BlipVisionModelTest'], } self.assertEqual(get_test_info.to_json(lowerCamelCase__ ) ,lowerCamelCase__ ) self.assertEqual(get_test_info.to_json(lowerCamelCase__ ) ,lowerCamelCase__ ) def __lowerCAmelCase ( self : int ): UpperCAmelCase__ = get_model_to_tester_mapping(lowerCamelCase__ ) UpperCAmelCase__ = get_model_to_tester_mapping(lowerCamelCase__ ) UpperCAmelCase__ = { 'BertForMaskedLM': ['BertModelTester'], 'BertForMultipleChoice': ['BertModelTester'], 'BertForNextSentencePrediction': ['BertModelTester'], 'BertForPreTraining': ['BertModelTester'], 'BertForQuestionAnswering': ['BertModelTester'], 'BertForSequenceClassification': ['BertModelTester'], 'BertForTokenClassification': ['BertModelTester'], 'BertLMHeadModel': ['BertModelTester'], 'BertModel': ['BertModelTester'], } UpperCAmelCase__ = { 'BlipForConditionalGeneration': ['BlipTextImageModelsModelTester'], 'BlipForImageTextRetrieval': ['BlipTextRetrievalModelTester'], 'BlipForQuestionAnswering': ['BlipVQAModelTester'], 'BlipModel': ['BlipModelTester'], 'BlipTextModel': ['BlipTextModelTester'], 'BlipVisionModel': ['BlipVisionModelTester'], } self.assertEqual(get_test_info.to_json(lowerCamelCase__ ) ,lowerCamelCase__ ) self.assertEqual(get_test_info.to_json(lowerCamelCase__ ) ,lowerCamelCase__ )

from abc import ABC, abstractmethod from argparse import ArgumentParser class UpperCAmelCase ( A_ ): @staticmethod @abstractmethod def _SCREAMING_SNAKE_CASE (snake_case__ : ArgumentParser ) -> str: '''simple docstring''' raise NotImplementedError() @abstractmethod def _SCREAMING_SNAKE_CASE (self : List[Any] ) -> Dict: '''simple docstring''' raise NotImplementedError()

import io import json import unittest from parameterized import parameterized from transformers import FSMTForConditionalGeneration, FSMTTokenizer from transformers.testing_utils import get_tests_dir, require_torch, slow, torch_device from utils import calculate_bleu __lowerCamelCase = get_tests_dir() + """/test_data/fsmt/fsmt_val_data.json""" with io.open(filename, """r""", encoding="""utf-8""") as f: __lowerCamelCase = json.load(f) @require_torch class UpperCAmelCase ( unittest.TestCase ): def _SCREAMING_SNAKE_CASE (self : Dict , snake_case__ : Optional[int] ) -> Any: '''simple docstring''' return FSMTTokenizer.from_pretrained(snake_case__ ) def _SCREAMING_SNAKE_CASE (self : Optional[Any] , snake_case__ : str ) -> List[str]: '''simple docstring''' snake_case : List[Any] = FSMTForConditionalGeneration.from_pretrained(snake_case__ ).to(snake_case__ ) if torch_device == "cuda": model.half() return model @parameterized.expand( [ ["en-ru", 26.0], ["ru-en", 22.0], ["en-de", 22.0], ["de-en", 29.0], ] ) @slow def _SCREAMING_SNAKE_CASE (self : str , snake_case__ : Tuple , snake_case__ : Optional[int] ) -> Any: '''simple docstring''' snake_case : Optional[int] = f"""facebook/wmt19-{pair}""" snake_case : Optional[Any] = self.get_tokenizer(snake_case__ ) snake_case : Dict = self.get_model(snake_case__ ) snake_case : List[Any] = bleu_data[pair]["src"] snake_case : int = bleu_data[pair]["tgt"] snake_case : Union[str, Any] = tokenizer(snake_case__ , return_tensors="pt" , truncation=snake_case__ , padding="longest" ).to(snake_case__ ) snake_case : str = model.generate( input_ids=batch.input_ids , num_beams=8 , ) snake_case : Optional[int] = tokenizer.batch_decode( snake_case__ , skip_special_tokens=snake_case__ , clean_up_tokenization_spaces=snake_case__ ) snake_case : Optional[int] = calculate_bleu(snake_case__ , snake_case__ ) print(snake_case__ ) self.assertGreaterEqual(scores["bleu"] , snake_case__ )

"""simple docstring""" import unittest from transformers import is_torch_available, is_vision_available from transformers.testing_utils import require_torch, require_vision, slow, torch_device if is_torch_available(): import torch from transformers import AutoModelForImageClassification if is_vision_available(): from transformers import AutoImageProcessor @require_torch @require_vision class _UpperCamelCase ( unittest.TestCase ): '''simple docstring''' @slow def snake_case ( self ): __lowerCAmelCase = AutoImageProcessor.from_pretrained("microsoft/dit-base-finetuned-rvlcdip" ) __lowerCAmelCase = AutoModelForImageClassification.from_pretrained("microsoft/dit-base-finetuned-rvlcdip" ) model.to(__a ) from datasets import load_dataset __lowerCAmelCase = load_dataset("nielsr/rvlcdip-demo" ) __lowerCAmelCase = dataset["train"][0]["image"].convert("RGB" ) __lowerCAmelCase = image_processor(__a , return_tensors="pt" ).to(__a ) # forward pass with torch.no_grad(): __lowerCAmelCase = model(**__a ) __lowerCAmelCase = outputs.logits __lowerCAmelCase = torch.Size((1, 16) ) self.assertEqual(logits.shape , __a ) __lowerCAmelCase = torch.tensor( [-0.4_1_5_8, -0.4_0_9_2, -0.4_3_4_7] , device=__a , dtype=torch.float , ) self.assertTrue(torch.allclose(logits[0, :3] , __a , atol=1e-4 ) )

import numpy as np def UpperCAmelCase ( a_ , a_ , a_ = 1E-12 , a_ = 1_0_0 , ) -> tuple[float, np.ndarray]: """simple docstring""" assert np.shape(a_ )[0] == np.shape(a_ )[1] # Ensure proper dimensionality. assert np.shape(a_ )[0] == np.shape(a_ )[0] # Ensure inputs are either both complex or both real assert np.iscomplexobj(a_ ) == np.iscomplexobj(a_ ) __A = np.iscomplexobj(a_ ) if is_complex: # Ensure complex input_matrix is Hermitian assert np.array_equal(a_ , input_matrix.conj().T ) # Set convergence to False. Will define convergence when we exceed max_iterations # or when we have small changes from one iteration to next. __A = False __A = 0 __A = 0 __A = 1E12 while not convergence: # Multiple matrix by the vector. __A = np.dot(a_ , a_ ) # Normalize the resulting output vector. __A = w / np.linalg.norm(a_ ) # Find rayleigh quotient # (faster than usual b/c we know vector is normalized already) __A = vector.conj().T if is_complex else vector.T __A = np.dot(a_ , np.dot(a_ , a_ ) ) # Check convergence. __A = np.abs(lambda_ - lambda_previous ) / lambda_ iterations += 1 if error <= error_tol or iterations >= max_iterations: __A = True __A = lambda_ if is_complex: __A = np.real(lambda_ ) return lambda_, vector def UpperCAmelCase ( ) -> None: """simple docstring""" __A = np.array([[4_1, 4, 2_0], [4, 2_6, 3_0], [2_0, 3_0, 5_0]] ) __A = np.array([4_1, 4, 2_0] ) __A = real_input_matrix.astype(np.complexaaa ) __A = np.triu(1J * complex_input_matrix , 1 ) complex_input_matrix += imag_matrix complex_input_matrix += -1 * imag_matrix.T __A = np.array([4_1, 4, 2_0] ).astype(np.complexaaa ) for problem_type in ["real", "complex"]: if problem_type == "real": __A = real_input_matrix __A = real_vector elif problem_type == "complex": __A = complex_input_matrix __A = complex_vector # Our implementation. __A , __A = power_iteration(a_ , a_ ) # Numpy implementation. # Get eigenvalues and eigenvectors using built-in numpy # eigh (eigh used for symmetric or hermetian matrices). __A , __A = np.linalg.eigh(a_ ) # Last eigenvalue is the maximum one. __A = eigen_values[-1] # Last column in this matrix is eigenvector corresponding to largest eigenvalue. __A = eigen_vectors[:, -1] # Check our implementation and numpy gives close answers. assert np.abs(eigen_value - eigen_value_max ) <= 1E-6 # Take absolute values element wise of each eigenvector. # as they are only unique to a minus sign. assert np.linalg.norm(np.abs(a_ ) - np.abs(a_ ) ) <= 1E-6 if __name__ == "__main__": import doctest doctest.testmod() test_power_iteration()

"""simple docstring""" import os import re from shutil import copyfile from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import AddedToken, PreTrainedTokenizer from ...utils import logging lowercase__ = logging.get_logger(__name__) lowercase__ = {"""vocab_file""": """spiece.model"""} lowercase__ = { """vocab_file""": { """google/bigbird-roberta-base""": """https://huggingface.co/google/bigbird-roberta-base/resolve/main/spiece.model""", """google/bigbird-roberta-large""": ( """https://huggingface.co/google/bigbird-roberta-large/resolve/main/spiece.model""" ), """google/bigbird-base-trivia-itc""": ( """https://huggingface.co/google/bigbird-base-trivia-itc/resolve/main/spiece.model""" ), } } lowercase__ = { """google/bigbird-roberta-base""": 4096, """google/bigbird-roberta-large""": 4096, """google/bigbird-base-trivia-itc""": 4096, } class __lowerCamelCase ( A_ ): '''simple docstring''' a_ : Any = VOCAB_FILES_NAMES a_ : Union[str, Any] = PRETRAINED_VOCAB_FILES_MAP a_ : Tuple = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES a_ : List[str] = ["input_ids", "attention_mask"] a_ : List[int] = [] def __init__( self : List[Any] , a_ : Optional[Any] , a_ : int="<unk>" , a_ : Optional[Any]="<s>" , a_ : Optional[Any]="</s>" , a_ : Dict="<pad>" , a_ : str="[SEP]" , a_ : Optional[Any]="[MASK]" , a_ : Any="[CLS]" , a_ : Optional[Dict[str, Any]] = None , **a_ : int , ): lowerCAmelCase_ : List[Any] = AddedToken(snake_case__ , lstrip=snake_case__ , rstrip=snake_case__ ) if isinstance(snake_case__ , snake_case__ ) else bos_token lowerCAmelCase_ : Tuple = AddedToken(snake_case__ , lstrip=snake_case__ , rstrip=snake_case__ ) if isinstance(snake_case__ , snake_case__ ) else eos_token lowerCAmelCase_ : str = AddedToken(snake_case__ , lstrip=snake_case__ , rstrip=snake_case__ ) if isinstance(snake_case__ , snake_case__ ) else unk_token lowerCAmelCase_ : int = AddedToken(snake_case__ , lstrip=snake_case__ , rstrip=snake_case__ ) if isinstance(snake_case__ , snake_case__ ) else pad_token lowerCAmelCase_ : Union[str, Any] = AddedToken(snake_case__ , lstrip=snake_case__ , rstrip=snake_case__ ) if isinstance(snake_case__ , snake_case__ ) else cls_token lowerCAmelCase_ : Union[str, Any] = AddedToken(snake_case__ , lstrip=snake_case__ , rstrip=snake_case__ ) if isinstance(snake_case__ , snake_case__ ) else sep_token # Mask token behave like a normal word, i.e. include the space before it lowerCAmelCase_ : str = AddedToken(snake_case__ , lstrip=snake_case__ , rstrip=snake_case__ ) if isinstance(snake_case__ , snake_case__ ) else mask_token lowerCAmelCase_ : Union[str, Any] = {} if sp_model_kwargs is None else sp_model_kwargs super().__init__( bos_token=snake_case__ , eos_token=snake_case__ , unk_token=snake_case__ , pad_token=snake_case__ , sep_token=snake_case__ , mask_token=snake_case__ , cls_token=snake_case__ , sp_model_kwargs=self.sp_model_kwargs , **snake_case__ , ) lowerCAmelCase_ : Optional[Any] = vocab_file lowerCAmelCase_ : Any = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(snake_case__ ) @property def lowerCamelCase ( self : Optional[int] ): return self.sp_model.get_piece_size() def lowerCamelCase ( self : int ): lowerCAmelCase_ : Dict = {self.convert_ids_to_tokens(snake_case__ ): i for i in range(self.vocab_size )} vocab.update(self.added_tokens_encoder ) return vocab def __getstate__( self : str ): lowerCAmelCase_ : Optional[int] = self.__dict__.copy() lowerCAmelCase_ : List[Any] = None return state def __setstate__( self : Union[str, Any] , a_ : Dict ): lowerCAmelCase_ : Union[str, Any] = d # for backward compatibility if not hasattr(self , "sp_model_kwargs" ): lowerCAmelCase_ : Optional[Any] = {} lowerCAmelCase_ : Union[str, Any] = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(self.vocab_file ) def lowerCamelCase ( self : Optional[int] , a_ : str ): return self.sp_model.encode(snake_case__ , out_type=snake_case__ ) def lowerCamelCase ( self : Any , a_ : Union[str, Any] ): return self.sp_model.piece_to_id(snake_case__ ) def lowerCamelCase ( self : Any , a_ : Union[str, Any] ): lowerCAmelCase_ : List[str] = self.sp_model.IdToPiece(snake_case__ ) return token def lowerCamelCase ( self : Any , a_ : Tuple ): lowerCAmelCase_ : Optional[Any] = [] lowerCAmelCase_ : Union[str, Any] = "" lowerCAmelCase_ : Optional[int] = False for token in tokens: # make sure that special tokens are not decoded using sentencepiece model if token in self.all_special_tokens: if not prev_is_special: out_string += " " out_string += self.sp_model.decode(snake_case__ ) + token lowerCAmelCase_ : List[Any] = True lowerCAmelCase_ : Optional[int] = [] else: current_sub_tokens.append(snake_case__ ) lowerCAmelCase_ : Any = False out_string += self.sp_model.decode(snake_case__ ) return out_string.strip() def lowerCamelCase ( self : List[Any] , a_ : List[int] , a_ : bool = False , a_ : bool = None , a_ : bool = True , **a_ : Optional[int] , ): lowerCAmelCase_ : Any = kwargs.pop("use_source_tokenizer" , snake_case__ ) lowerCAmelCase_ : List[str] = self.convert_ids_to_tokens(snake_case__ , skip_special_tokens=snake_case__ ) # To avoid mixing byte-level and unicode for byte-level BPT # we need to build string separately for added tokens and byte-level tokens # cf. https://github.com/huggingface/transformers/issues/1133 lowerCAmelCase_ : List[str] = [] lowerCAmelCase_ : Optional[Any] = [] for token in filtered_tokens: if skip_special_tokens and token in self.all_special_ids: continue if token in self.added_tokens_encoder: if current_sub_text: sub_texts.append(self.convert_tokens_to_string(snake_case__ ) ) lowerCAmelCase_ : Optional[Any] = [] sub_texts.append(snake_case__ ) else: current_sub_text.append(snake_case__ ) if current_sub_text: sub_texts.append(self.convert_tokens_to_string(snake_case__ ) ) # Mimic the behavior of the Rust tokenizer: # No space before [MASK] and [SEP] if spaces_between_special_tokens: lowerCAmelCase_ : Any = re.sub(R" (\[(MASK|SEP)\])" , R"\1" , " ".join(snake_case__ ) ) else: lowerCAmelCase_ : Optional[int] = "".join(snake_case__ ) lowerCAmelCase_ : List[Any] = ( clean_up_tokenization_spaces if clean_up_tokenization_spaces is not None else self.clean_up_tokenization_spaces ) if clean_up_tokenization_spaces: lowerCAmelCase_ : int = self.clean_up_tokenization(snake_case__ ) return clean_text else: return text def lowerCamelCase ( self : List[Any] , a_ : str , a_ : Optional[str] = None ): if not os.path.isdir(snake_case__ ): logger.error(f'''Vocabulary path ({save_directory}) should be a directory''' ) return lowerCAmelCase_ : List[Any] = os.path.join( snake_case__ , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(snake_case__ ) and os.path.isfile(self.vocab_file ): copyfile(self.vocab_file , snake_case__ ) elif not os.path.isfile(self.vocab_file ): with open(snake_case__ , "wb" ) as fi: lowerCAmelCase_ : int = self.sp_model.serialized_model_proto() fi.write(snake_case__ ) return (out_vocab_file,) def lowerCamelCase ( self : int , a_ : List[int] , a_ : Optional[List[int]] = None ): if token_ids_a is None: return [self.cls_token_id] + token_ids_a + [self.sep_token_id] lowerCAmelCase_ : Dict = [self.cls_token_id] lowerCAmelCase_ : Any = [self.sep_token_id] return cls + token_ids_a + sep + token_ids_a + sep def lowerCamelCase ( self : Optional[int] , a_ : List[int] , a_ : Optional[List[int]] = None , a_ : bool = False ): if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=snake_case__ , token_ids_a=snake_case__ , already_has_special_tokens=snake_case__ ) if token_ids_a is None: return [1] + ([0] * len(snake_case__ )) + [1] return [1] + ([0] * len(snake_case__ )) + [1] + ([0] * len(snake_case__ )) + [1] def lowerCamelCase ( self : Optional[Any] , a_ : List[int] , a_ : Optional[List[int]] = None ): lowerCAmelCase_ : str = [self.sep_token_id] lowerCAmelCase_ : Optional[Any] = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1]

"""simple docstring""" import copy import inspect import unittest from transformers import AutoBackbone from transformers.configuration_utils import PretrainedConfig from transformers.testing_utils import require_timm, require_torch, torch_device from transformers.utils.import_utils import is_torch_available from ...test_backbone_common import BackboneTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor if is_torch_available(): import torch from transformers import TimmBackbone, TimmBackboneConfig from ...test_pipeline_mixin import PipelineTesterMixin class __lowerCamelCase : '''simple docstring''' def __init__( self : List[str] , a_ : Any , a_ : Any=None , a_ : int=None , a_ : str=None , a_ : Optional[int]="resnet50" , a_ : str=3 , a_ : str=32 , a_ : Union[str, Any]=3 , a_ : Tuple=True , a_ : List[str]=True , ): lowerCAmelCase_ : Optional[int] = parent lowerCAmelCase_ : Dict = out_indices if out_indices is not None else [4] lowerCAmelCase_ : int = stage_names lowerCAmelCase_ : Optional[Any] = out_features lowerCAmelCase_ : Tuple = backbone lowerCAmelCase_ : List[str] = batch_size lowerCAmelCase_ : Tuple = image_size lowerCAmelCase_ : List[Any] = num_channels lowerCAmelCase_ : Optional[int] = use_pretrained_backbone lowerCAmelCase_ : List[Any] = is_training def lowerCamelCase ( self : Any ): lowerCAmelCase_ : Tuple = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) lowerCAmelCase_ : Optional[int] = self.get_config() return config, pixel_values def lowerCamelCase ( self : Dict ): return TimmBackboneConfig( image_size=self.image_size , num_channels=self.num_channels , out_features=self.out_features , out_indices=self.out_indices , stage_names=self.stage_names , use_pretrained_backbone=self.use_pretrained_backbone , backbone=self.backbone , ) def lowerCamelCase ( self : Union[str, Any] , a_ : str , a_ : Optional[int] ): lowerCAmelCase_ : Union[str, Any] = TimmBackbone(config=a_ ) model.to(a_ ) model.eval() with torch.no_grad(): lowerCAmelCase_ : int = model(a_ ) self.parent.assertEqual( result.feature_map[-1].shape , (self.batch_size, model.channels[-1], 14, 14) , ) def lowerCamelCase ( self : Dict ): lowerCAmelCase_ : List[Any] = self.prepare_config_and_inputs() lowerCAmelCase_ , lowerCAmelCase_ : Optional[int] = config_and_inputs lowerCAmelCase_ : str = {"pixel_values": pixel_values} return config, inputs_dict @require_torch @require_timm class __lowerCamelCase ( A__ , A__ , A__ , unittest.TestCase ): '''simple docstring''' a_ : Union[str, Any] = (TimmBackbone,) if is_torch_available() else () a_ : int = {"""feature-extraction""": TimmBackbone} if is_torch_available() else {} a_ : Union[str, Any] = False a_ : str = False a_ : List[Any] = False a_ : Dict = False def lowerCamelCase ( self : Any ): lowerCAmelCase_ : Union[str, Any] = TimmBackboneModelTester(self ) lowerCAmelCase_ : List[str] = ConfigTester(self , config_class=a_ , has_text_modality=a_ ) def lowerCamelCase ( self : Dict ): self.config_tester.create_and_test_config_to_json_string() self.config_tester.create_and_test_config_to_json_file() self.config_tester.create_and_test_config_from_and_save_pretrained() self.config_tester.create_and_test_config_with_num_labels() self.config_tester.check_config_can_be_init_without_params() self.config_tester.check_config_arguments_init() def lowerCamelCase ( self : List[Any] ): lowerCAmelCase_ : Optional[int] = "resnet18" lowerCAmelCase_ : List[Any] = "microsoft/resnet-18" lowerCAmelCase_ : Tuple = AutoBackbone.from_pretrained(a_ , use_timm_backbone=a_ ) lowerCAmelCase_ : str = AutoBackbone.from_pretrained(a_ ) self.assertEqual(len(timm_model.out_features ) , len(transformers_model.out_features ) ) self.assertEqual(len(timm_model.stage_names ) , len(transformers_model.stage_names ) ) self.assertEqual(timm_model.channels , transformers_model.channels ) # Out indices are set to the last layer by default. For timm models, we don't know # the number of layers in advance, so we set it to (-1,), whereas for transformers # models, we set it to [len(stage_names) - 1] (kept for backward compatibility). self.assertEqual(timm_model.out_indices , (-1,) ) self.assertEqual(transformers_model.out_indices , [len(timm_model.stage_names ) - 1] ) lowerCAmelCase_ : Dict = AutoBackbone.from_pretrained(a_ , use_timm_backbone=a_ , out_indices=[1, 2, 3] ) lowerCAmelCase_ : Any = AutoBackbone.from_pretrained(a_ , out_indices=[1, 2, 3] ) self.assertEqual(timm_model.out_indices , transformers_model.out_indices ) self.assertEqual(len(timm_model.out_features ) , len(transformers_model.out_features ) ) self.assertEqual(timm_model.channels , transformers_model.channels ) @unittest.skip("TimmBackbone doesn't support feed forward chunking" ) def lowerCamelCase ( self : Optional[int] ): pass @unittest.skip("TimmBackbone doesn't have num_hidden_layers attribute" ) def lowerCamelCase ( self : Dict ): pass @unittest.skip("TimmBackbone initialization is managed on the timm side" ) def lowerCamelCase ( self : List[Any] ): pass @unittest.skip("TimmBackbone models doesn't have inputs_embeds" ) def lowerCamelCase ( self : Dict ): pass @unittest.skip("TimmBackbone models doesn't have inputs_embeds" ) def lowerCamelCase ( self : Any ): pass @unittest.skip("TimmBackbone model cannot be created without specifying a backbone checkpoint" ) def lowerCamelCase ( self : Tuple ): pass @unittest.skip("Only checkpoints on timm can be loaded into TimmBackbone" ) def lowerCamelCase ( self : str ): pass @unittest.skip("model weights aren't tied in TimmBackbone." ) def lowerCamelCase ( self : Any ): pass @unittest.skip("model weights aren't tied in TimmBackbone." ) def lowerCamelCase ( self : List[str] ): pass @unittest.skip("Only checkpoints on timm can be loaded into TimmBackbone" ) def lowerCamelCase ( self : Tuple ): pass @unittest.skip("Only checkpoints on timm can be loaded into TimmBackbone" ) def lowerCamelCase ( self : Optional[int] ): pass @unittest.skip("TimmBackbone doesn't have hidden size info in its configuration." ) def lowerCamelCase ( self : Dict ): pass @unittest.skip("TimmBackbone doesn't support output_attentions." ) def lowerCamelCase ( self : int ): pass @unittest.skip("Safetensors is not supported by timm." ) def lowerCamelCase ( self : Union[str, Any] ): pass @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests." ) def lowerCamelCase ( self : Union[str, Any] ): pass def lowerCamelCase ( self : Optional[int] ): lowerCAmelCase_ , lowerCAmelCase_ : Union[str, Any] = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: lowerCAmelCase_ : str = model_class(a_ ) lowerCAmelCase_ : List[str] = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic lowerCAmelCase_ : str = [*signature.parameters.keys()] lowerCAmelCase_ : List[Any] = ["pixel_values"] self.assertListEqual(arg_names[:1] , a_ ) def lowerCamelCase ( self : Any ): lowerCAmelCase_ , lowerCAmelCase_ : List[str] = self.model_tester.prepare_config_and_inputs_for_common() lowerCAmelCase_ : Optional[int] = True lowerCAmelCase_ : List[Any] = self.has_attentions # no need to test all models as different heads yield the same functionality lowerCAmelCase_ : int = self.all_model_classes[0] lowerCAmelCase_ : Optional[int] = model_class(a_ ) model.to(a_ ) lowerCAmelCase_ : Union[str, Any] = self._prepare_for_class(a_ , a_ ) lowerCAmelCase_ : str = model(**a_ ) lowerCAmelCase_ : Any = outputs[0][-1] # Encoder-/Decoder-only models lowerCAmelCase_ : Optional[int] = outputs.hidden_states[0] hidden_states.retain_grad() if self.has_attentions: lowerCAmelCase_ : Optional[int] = outputs.attentions[0] attentions.retain_grad() output.flatten()[0].backward(retain_graph=a_ ) self.assertIsNotNone(hidden_states.grad ) if self.has_attentions: self.assertIsNotNone(attentions.grad ) def lowerCamelCase ( self : str ): lowerCAmelCase_ , lowerCAmelCase_ : Optional[int] = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: lowerCAmelCase_ : Dict = model_class(a_ ) model.to(a_ ) model.eval() lowerCAmelCase_ : Tuple = model(**a_ ) self.assertEqual(len(result.feature_maps ) , len(config.out_indices ) ) self.assertEqual(len(model.channels ) , len(config.out_indices ) ) # Check output of last stage is taken if out_features=None, out_indices=None lowerCAmelCase_ : Optional[int] = copy.deepcopy(a_ ) lowerCAmelCase_ : Tuple = None lowerCAmelCase_ : Any = model_class(a_ ) model.to(a_ ) model.eval() lowerCAmelCase_ : int = model(**a_ ) self.assertEqual(len(result.feature_maps ) , 1 ) self.assertEqual(len(model.channels ) , 1 ) # Check backbone can be initialized with fresh weights lowerCAmelCase_ : str = copy.deepcopy(a_ ) lowerCAmelCase_ : Dict = False lowerCAmelCase_ : Optional[int] = model_class(a_ ) model.to(a_ ) model.eval() lowerCAmelCase_ : Optional[Any] = model(**a_ )

from math import factorial, radians def lowercase ( SCREAMING_SNAKE_CASE__ : str , SCREAMING_SNAKE_CASE__ : Dict = 18 , SCREAMING_SNAKE_CASE__ : Union[str, Any] = 10 ) -> Union[str, Any]: _snake_case : List[Any] = angle_in_degrees - ((angle_in_degrees // 3_6_0.0) * 3_6_0.0) # Converting from degrees to radians _snake_case : Dict = radians(_UpperCamelCase ) _snake_case : Optional[Any] = angle_in_radians _snake_case : Optional[int] = 3 _snake_case : Any = -1 for _ in range(_UpperCamelCase ): result += (b * (angle_in_radians**a)) / factorial(_UpperCamelCase ) _snake_case : Union[str, Any] = -b # One positive term and the next will be negative and so on... a += 2 # Increased by 2 for every term. return round(_UpperCamelCase , _UpperCamelCase ) if __name__ == "__main__": __import__("""doctest""").testmod()

"""simple docstring""" from __future__ import annotations lowerCamelCase__ = list[tuple[int, int]] lowerCamelCase__ = [ [0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0], # 0 are free path whereas 1's are obstacles [0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0], ] lowerCamelCase__ = ([-1, 0], [0, -1], [1, 0], [0, 1]) # up, left, down, right class A__ : def __init__( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , ): __lowerCAmelCase : int = pos_x __lowerCAmelCase : Optional[Any] = pos_y __lowerCAmelCase : Optional[int] = (pos_y, pos_x) __lowerCAmelCase : Union[str, Any] = goal_x __lowerCAmelCase : Any = goal_y __lowerCAmelCase : Optional[Any] = g_cost __lowerCAmelCase : Any = parent __lowerCAmelCase : Union[str, Any] = self.calculate_heuristic() def __lowerCamelCase ( self ): __lowerCAmelCase : str = abs(self.pos_x - self.goal_x ) __lowerCAmelCase : str = abs(self.pos_y - self.goal_y ) return dx + dy def __lt__( self , _SCREAMING_SNAKE_CASE ): return self.f_cost < other.f_cost class A__ : def __init__( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ): __lowerCAmelCase : Optional[int] = Node(start[1] , start[0] , goal[1] , goal[0] , 0 , _SCREAMING_SNAKE_CASE ) __lowerCAmelCase : Any = Node(goal[1] , goal[0] , goal[1] , goal[0] , 9_99_99 , _SCREAMING_SNAKE_CASE ) __lowerCAmelCase : Tuple = [self.start] __lowerCAmelCase : list[Node] = [] __lowerCAmelCase : str = False def __lowerCamelCase ( self ): while self.open_nodes: # Open Nodes are sorted using __lt__ self.open_nodes.sort() __lowerCAmelCase : Optional[int] = self.open_nodes.pop(0 ) if current_node.pos == self.target.pos: __lowerCAmelCase : Union[str, Any] = True return self.retrace_path(_SCREAMING_SNAKE_CASE ) self.closed_nodes.append(_SCREAMING_SNAKE_CASE ) __lowerCAmelCase : Optional[Any] = self.get_successors(_SCREAMING_SNAKE_CASE ) for child_node in successors: if child_node in self.closed_nodes: continue if child_node not in self.open_nodes: self.open_nodes.append(_SCREAMING_SNAKE_CASE ) else: # retrieve the best current path __lowerCAmelCase : Optional[Any] = self.open_nodes.pop(self.open_nodes.index(_SCREAMING_SNAKE_CASE ) ) if child_node.g_cost < better_node.g_cost: self.open_nodes.append(_SCREAMING_SNAKE_CASE ) else: self.open_nodes.append(_SCREAMING_SNAKE_CASE ) if not self.reached: return [self.start.pos] return None def __lowerCamelCase ( self , _SCREAMING_SNAKE_CASE ): __lowerCAmelCase : Dict = [] for action in delta: __lowerCAmelCase : Optional[int] = parent.pos_x + action[1] __lowerCAmelCase : Union[str, Any] = parent.pos_y + action[0] if not (0 <= pos_x <= len(grid[0] ) - 1 and 0 <= pos_y <= len(_SCREAMING_SNAKE_CASE ) - 1): continue if grid[pos_y][pos_x] != 0: continue successors.append( Node( _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , self.target.pos_y , self.target.pos_x , parent.g_cost + 1 , _SCREAMING_SNAKE_CASE , ) ) return successors def __lowerCamelCase ( self , _SCREAMING_SNAKE_CASE ): __lowerCAmelCase : Union[str, Any] = node __lowerCAmelCase : Optional[int] = [] while current_node is not None: path.append((current_node.pos_y, current_node.pos_x) ) __lowerCAmelCase : int = current_node.parent path.reverse() return path if __name__ == "__main__": lowerCamelCase__ = (0, 0) lowerCamelCase__ = (len(grid) - 1, len(grid[0]) - 1) for elem in grid: print(elem) print("""------""") lowerCamelCase__ = GreedyBestFirst(init, goal) lowerCamelCase__ = greedy_bf.search() if path: for pos_x, pos_y in path: lowerCamelCase__ = 2 for elem in grid: print(elem)

UpperCamelCase = {'''a''': ['''c''', '''b'''], '''b''': ['''d''', '''e'''], '''c''': [], '''d''': [], '''e''': []} UpperCamelCase = ['''a''', '''b''', '''c''', '''d''', '''e'''] def lowercase_ ( _lowerCamelCase : str , _lowerCamelCase : Optional[int] , _lowerCamelCase : Tuple): lowercase__ : Any = start # add current to visited visited.append(_lowerCamelCase) lowercase__ : List[Any] = edges[current] for neighbor in neighbors: # if neighbor not in visited, visit if neighbor not in visited: lowercase__ : Optional[Any] = topological_sort(_lowerCamelCase , _lowerCamelCase , _lowerCamelCase) # if all neighbors visited add current to sort sort.append(_lowerCamelCase) # if all vertices haven't been visited select a new one to visit if len(_lowerCamelCase) != len(_lowerCamelCase): for vertice in vertices: if vertice not in visited: lowercase__ : Optional[Any] = topological_sort(_lowerCamelCase , _lowerCamelCase , _lowerCamelCase) # return sort return sort if __name__ == "__main__": UpperCamelCase = topological_sort('''a''', [], []) print(sort)

def lowercase_ ( _lowerCamelCase : int , _lowerCamelCase : int): while a != 0: lowercase__ , lowercase__ : Dict = b % a, a return b def lowercase_ ( _lowerCamelCase : int , _lowerCamelCase : int): if gcd(_lowerCamelCase , _lowerCamelCase) != 1: lowercase__ : Tuple = f'''mod inverse of {a!r} and {m!r} does not exist''' raise ValueError(_lowerCamelCase) lowercase__ , lowercase__ , lowercase__ : Optional[int] = 1, 0, a lowercase__ , lowercase__ , lowercase__ : Union[str, Any] = 0, 1, m while va != 0: lowercase__ : Tuple = ua // va lowercase__ , lowercase__ , lowercase__ , lowercase__ , lowercase__ , lowercase__ : Any = (ua - q * va), (ua - q * va), (ua - q * va), va, va, va return ua % m

import logging import os import sys from dataclasses import dataclass, field from typing import Optional import torch from datasets import load_dataset from torchvision.transforms import Compose, Lambda, Normalize, RandomHorizontalFlip, RandomResizedCrop, ToTensor from torchvision.transforms.functional import InterpolationMode import transformers from transformers import ( HfArgumentParser, Trainer, TrainingArguments, ViTImageProcessor, ViTMAEConfig, ViTMAEForPreTraining, ) from transformers.trainer_utils import get_last_checkpoint from transformers.utils import check_min_version, send_example_telemetry from transformers.utils.versions import require_version UpperCAmelCase_ = logging.getLogger(__name__) # Will error if the minimal version of Transformers is not installed. Remove at your own risks. check_min_version('4.31.0') require_version('datasets>=1.8.0', 'To fix: pip install -r examples/pytorch/image-pretraining/requirements.txt') @dataclass class lowerCamelCase__: UpperCAmelCase__ : Optional[str] = field( default='cifar10' , metadata={'help': 'Name of a dataset from the datasets package'}) UpperCAmelCase__ : Optional[str] = field( default=__lowerCamelCase , metadata={'help': 'The configuration name of the dataset to use (via the datasets library).'}) UpperCAmelCase__ : Optional[str] = field( default=__lowerCamelCase , metadata={'help': 'The column name of the images in the files.'}) UpperCAmelCase__ : Optional[str] = field(default=__lowerCamelCase , metadata={'help': 'A folder containing the training data.'}) UpperCAmelCase__ : Optional[str] = field(default=__lowerCamelCase , metadata={'help': 'A folder containing the validation data.'}) UpperCAmelCase__ : Optional[float] = field( default=0.15 , metadata={'help': 'Percent to split off of train for validation.'}) UpperCAmelCase__ : Optional[int] = field( default=__lowerCamelCase , metadata={ 'help': ( 'For debugging purposes or quicker training, truncate the number of training examples to this ' 'value if set.' ) } , ) UpperCAmelCase__ : Optional[int] = field( default=__lowerCamelCase , metadata={ 'help': ( 'For debugging purposes or quicker training, truncate the number of evaluation examples to this ' 'value if set.' ) } , ) def lowerCAmelCase__ ( self: str ): __lowerCamelCase = {} if self.train_dir is not None: __lowerCamelCase = self.train_dir if self.validation_dir is not None: __lowerCamelCase = self.validation_dir __lowerCamelCase = data_files if data_files else None @dataclass class lowerCamelCase__: UpperCAmelCase__ : str = field( default=__lowerCamelCase , metadata={ 'help': ( 'The model checkpoint for weights initialization.Don\'t set if you want to train a model from scratch.' ) } , ) UpperCAmelCase__ : Optional[str] = field( default=__lowerCamelCase , metadata={'help': 'Pretrained config name or path if not the same as model_name_or_path'}) UpperCAmelCase__ : Optional[str] = field( default=__lowerCamelCase , metadata={ 'help': ( 'Override some existing default config settings when a model is trained from scratch. Example: ' 'n_embd=10,resid_pdrop=0.2,scale_attn_weights=false,summary_type=cls_index' ) } , ) UpperCAmelCase__ : Optional[str] = field( default=__lowerCamelCase , metadata={'help': 'Where do you want to store the pretrained models downloaded from s3'}) UpperCAmelCase__ : str = field( default='main' , metadata={'help': 'The specific model version to use (can be a branch name, tag name or commit id).'} , ) UpperCAmelCase__ : str = field(default=__lowerCamelCase , metadata={'help': 'Name or path of preprocessor config.'}) UpperCAmelCase__ : bool = field( default=__lowerCamelCase , metadata={ 'help': ( 'Will use the token generated when running `huggingface-cli login` (necessary to use this script ' 'with private models).' ) } , ) UpperCAmelCase__ : float = field( default=0.75 , metadata={'help': 'The ratio of the number of masked tokens in the input sequence.'}) UpperCAmelCase__ : bool = field( default=__lowerCamelCase , metadata={'help': 'Whether or not to train with normalized pixel values as target.'}) @dataclass class lowerCamelCase__( __lowerCamelCase): UpperCAmelCase__ : float = field( default=1E-3 , metadata={'help': 'Base learning rate: absolute_lr = base_lr * total_batch_size / 256.'}) def lowerCamelCase__ ( A__ : List[str] ): '''simple docstring''' __lowerCamelCase = torch.stack([example["""pixel_values"""] for example in examples] ) return {"pixel_values": pixel_values} def lowerCamelCase__ ( ): '''simple docstring''' __lowerCamelCase = HfArgumentParser((ModelArguments, DataTrainingArguments, CustomTrainingArguments) ) if len(sys.argv ) == 2 and sys.argv[1].endswith(""".json""" ): # If we pass only one argument to the script and it's the path to a json file, # let's parse it to get our arguments. __lowerCamelCase, __lowerCamelCase, __lowerCamelCase = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1] ) ) else: __lowerCamelCase, __lowerCamelCase, __lowerCamelCase = parser.parse_args_into_dataclasses() # Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The # information sent is the one passed as arguments along with your Python/PyTorch versions. send_example_telemetry("""run_mae""" , A__ , A__ ) # Setup logging logging.basicConfig( format="""%(asctime)s - %(levelname)s - %(name)s - %(message)s""" , datefmt="""%m/%d/%Y %H:%M:%S""" , handlers=[logging.StreamHandler(sys.stdout )] , ) if training_args.should_log: # The default of training_args.log_level is passive, so we set log level at info here to have that default. transformers.utils.logging.set_verbosity_info() __lowerCamelCase = training_args.get_process_log_level() logger.setLevel(A__ ) transformers.utils.logging.set_verbosity(A__ ) transformers.utils.logging.enable_default_handler() transformers.utils.logging.enable_explicit_format() # Log on each process the small summary: logger.warning( f'Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}' + f'distributed training: {bool(training_args.local_rank != -1 )}, 16-bits training: {training_args.fpaa}' ) logger.info(f'Training/evaluation parameters {training_args}' ) # Detecting last checkpoint. __lowerCamelCase = None if os.path.isdir(training_args.output_dir ) and training_args.do_train and not training_args.overwrite_output_dir: __lowerCamelCase = get_last_checkpoint(training_args.output_dir ) if last_checkpoint is None and len(os.listdir(training_args.output_dir ) ) > 0: raise ValueError( f'Output directory ({training_args.output_dir}) already exists and is not empty. ' """Use --overwrite_output_dir to overcome.""" ) elif last_checkpoint is not None and training_args.resume_from_checkpoint is None: logger.info( f'Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change ' """the `--output_dir` or add `--overwrite_output_dir` to train from scratch.""" ) # Initialize our dataset. __lowerCamelCase = load_dataset( data_args.dataset_name , data_args.dataset_config_name , data_files=data_args.data_files , cache_dir=model_args.cache_dir , use_auth_token=True if model_args.use_auth_token else None , ) # If we don't have a validation split, split off a percentage of train as validation. __lowerCamelCase = None if """validation""" in ds.keys() else data_args.train_val_split if isinstance(data_args.train_val_split , A__ ) and data_args.train_val_split > 0.0: __lowerCamelCase = ds["""train"""].train_test_split(data_args.train_val_split ) __lowerCamelCase = split["""train"""] __lowerCamelCase = split["""test"""] # Load pretrained model and image processor # # Distributed training: # The .from_pretrained methods guarantee that only one local process can concurrently # download model & vocab. __lowerCamelCase = { """cache_dir""": model_args.cache_dir, """revision""": model_args.model_revision, """use_auth_token""": True if model_args.use_auth_token else None, } if model_args.config_name: __lowerCamelCase = ViTMAEConfig.from_pretrained(model_args.config_name , **A__ ) elif model_args.model_name_or_path: __lowerCamelCase = ViTMAEConfig.from_pretrained(model_args.model_name_or_path , **A__ ) else: __lowerCamelCase = ViTMAEConfig() logger.warning("""You are instantiating a new config instance from scratch.""" ) if model_args.config_overrides is not None: logger.info(f'Overriding config: {model_args.config_overrides}' ) config.update_from_string(model_args.config_overrides ) logger.info(f'New config: {config}' ) # adapt config config.update( { """mask_ratio""": model_args.mask_ratio, """norm_pix_loss""": model_args.norm_pix_loss, } ) # create image processor if model_args.image_processor_name: __lowerCamelCase = ViTImageProcessor.from_pretrained(model_args.image_processor_name , **A__ ) elif model_args.model_name_or_path: __lowerCamelCase = ViTImageProcessor.from_pretrained(model_args.model_name_or_path , **A__ ) else: __lowerCamelCase = ViTImageProcessor() # create model if model_args.model_name_or_path: __lowerCamelCase = ViTMAEForPreTraining.from_pretrained( model_args.model_name_or_path , from_tf=bool(""".ckpt""" in model_args.model_name_or_path ) , config=A__ , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , ) else: logger.info("""Training new model from scratch""" ) __lowerCamelCase = ViTMAEForPreTraining(A__ ) if training_args.do_train: __lowerCamelCase = ds["""train"""].column_names else: __lowerCamelCase = ds["""validation"""].column_names if data_args.image_column_name is not None: __lowerCamelCase = data_args.image_column_name elif "image" in column_names: __lowerCamelCase = """image""" elif "img" in column_names: __lowerCamelCase = """img""" else: __lowerCamelCase = column_names[0] # transformations as done in original MAE paper # source: https://github.com/facebookresearch/mae/blob/main/main_pretrain.py if "shortest_edge" in image_processor.size: __lowerCamelCase = image_processor.size["""shortest_edge"""] else: __lowerCamelCase = (image_processor.size["""height"""], image_processor.size["""width"""]) __lowerCamelCase = Compose( [ Lambda(lambda A__ : img.convert("""RGB""" ) if img.mode != "RGB" else img ), RandomResizedCrop(A__ , scale=(0.2, 1.0) , interpolation=InterpolationMode.BICUBIC ), RandomHorizontalFlip(), ToTensor(), Normalize(mean=image_processor.image_mean , std=image_processor.image_std ), ] ) def preprocess_images(A__ : Optional[int] ): __lowerCamelCase = [transforms(A__ ) for image in examples[image_column_name]] return examples if training_args.do_train: if "train" not in ds: raise ValueError("""--do_train requires a train dataset""" ) if data_args.max_train_samples is not None: __lowerCamelCase = ds["""train"""].shuffle(seed=training_args.seed ).select(range(data_args.max_train_samples ) ) # Set the training transforms ds["train"].set_transform(A__ ) if training_args.do_eval: if "validation" not in ds: raise ValueError("""--do_eval requires a validation dataset""" ) if data_args.max_eval_samples is not None: __lowerCamelCase = ( ds["""validation"""].shuffle(seed=training_args.seed ).select(range(data_args.max_eval_samples ) ) ) # Set the validation transforms ds["validation"].set_transform(A__ ) # Compute absolute learning rate __lowerCamelCase = ( training_args.train_batch_size * training_args.gradient_accumulation_steps * training_args.world_size ) if training_args.base_learning_rate is not None: __lowerCamelCase = training_args.base_learning_rate * total_train_batch_size / 256 # Initialize our trainer __lowerCamelCase = Trainer( model=A__ , args=A__ , train_dataset=ds["""train"""] if training_args.do_train else None , eval_dataset=ds["""validation"""] if training_args.do_eval else None , tokenizer=A__ , data_collator=A__ , ) # Training if training_args.do_train: __lowerCamelCase = None if training_args.resume_from_checkpoint is not None: __lowerCamelCase = training_args.resume_from_checkpoint elif last_checkpoint is not None: __lowerCamelCase = last_checkpoint __lowerCamelCase = trainer.train(resume_from_checkpoint=A__ ) trainer.save_model() trainer.log_metrics("""train""" , train_result.metrics ) trainer.save_metrics("""train""" , train_result.metrics ) trainer.save_state() # Evaluation if training_args.do_eval: __lowerCamelCase = trainer.evaluate() trainer.log_metrics("""eval""" , A__ ) trainer.save_metrics("""eval""" , A__ ) # Write model card and (optionally) push to hub __lowerCamelCase = { """tasks""": """masked-auto-encoding""", """dataset""": data_args.dataset_name, """tags""": ["""masked-auto-encoding"""], } if training_args.push_to_hub: trainer.push_to_hub(**A__ ) else: trainer.create_model_card(**A__ ) def lowerCamelCase__ ( A__ : Tuple ): '''simple docstring''' main() if __name__ == "__main__": main()

from transformers import DistilBertTokenizer, DistilBertTokenizerFast from transformers.testing_utils import require_tokenizers, slow from ..bert.test_tokenization_bert import BertTokenizationTest @require_tokenizers class lowerCamelCase__( __lowerCamelCase): UpperCAmelCase__ : Dict = DistilBertTokenizer UpperCAmelCase__ : Dict = DistilBertTokenizerFast UpperCAmelCase__ : Tuple = True @slow def lowerCAmelCase__ ( self: Tuple ): __lowerCamelCase = DistilBertTokenizer.from_pretrained("""distilbert-base-uncased""" ) __lowerCamelCase = tokenizer.encode("""sequence builders""" , add_special_tokens=UpperCamelCase_ ) __lowerCamelCase = tokenizer.encode("""multi-sequence build""" , add_special_tokens=UpperCamelCase_ ) __lowerCamelCase = tokenizer.build_inputs_with_special_tokens(UpperCamelCase_ ) __lowerCamelCase = tokenizer.build_inputs_with_special_tokens(UpperCamelCase_ , UpperCamelCase_ ) assert encoded_sentence == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] assert encoded_pair == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [ tokenizer.sep_token_id ]

from ...configuration_utils import PretrainedConfig from ...utils import logging lowerCamelCase_ : Tuple = logging.get_logger(__name__) lowerCamelCase_ : List[Any] = { """google/fnet-base""": """https://huggingface.co/google/fnet-base/resolve/main/config.json""", """google/fnet-large""": """https://huggingface.co/google/fnet-large/resolve/main/config.json""" # See all FNet models at https://huggingface.co/models?filter=fnet } class a__ ( __snake_case ): A__ : Dict = 'fnet' def __init__( self , UpperCAmelCase=3_2_0_0_0 , UpperCAmelCase=7_6_8 , UpperCAmelCase=1_2 , UpperCAmelCase=3_0_7_2 , UpperCAmelCase="gelu_new" , UpperCAmelCase=0.1 , UpperCAmelCase=5_1_2 , UpperCAmelCase=4 , UpperCAmelCase=0.02 , UpperCAmelCase=1e-12 , UpperCAmelCase=False , UpperCAmelCase=5_1_2 , UpperCAmelCase=3 , UpperCAmelCase=1 , UpperCAmelCase=2 , **UpperCAmelCase , ) -> Dict: super().__init__(pad_token_id=UpperCAmelCase , bos_token_id=UpperCAmelCase , eos_token_id=UpperCAmelCase , **UpperCAmelCase ) __a = vocab_size __a = max_position_embeddings __a = hidden_size __a = num_hidden_layers __a = intermediate_size __a = hidden_act __a = hidden_dropout_prob __a = initializer_range __a = type_vocab_size __a = layer_norm_eps __a = use_tpu_fourier_optimizations __a = tpu_short_seq_length

from datetime import datetime import matplotlib.pyplot as plt import torch def lowerCAmelCase( __lowerCamelCase ): for param in module.parameters(): __a = False def lowerCAmelCase( ): __a = 'cuda' if torch.cuda.is_available() else 'cpu' if torch.backends.mps.is_available() and torch.backends.mps.is_built(): __a = 'mps' if device == "mps": print( 'WARNING: MPS currently doesn\'t seem to work, and messes up backpropagation without any visible torch' ' errors. I recommend using CUDA on a colab notebook or CPU instead if you\'re facing inexplicable issues' ' with generations.' ) return device def lowerCAmelCase( __lowerCamelCase ): __a = plt.imshow(__lowerCamelCase ) fig.axes.get_xaxis().set_visible(__lowerCamelCase ) fig.axes.get_yaxis().set_visible(__lowerCamelCase ) plt.show() def lowerCAmelCase( ): __a = datetime.now() __a = current_time.strftime('%H:%M:%S' ) return timestamp

'''simple docstring''' import math import time from transformers import Trainer, is_torch_tpu_available from transformers.trainer_utils import PredictionOutput, speed_metrics if is_torch_tpu_available(check_device=False): import torch_xla.core.xla_model as xm import torch_xla.debug.metrics as met class __UpperCAmelCase ( _lowerCamelCase ): def __init__( self , *lowerCAmelCase_ , lowerCAmelCase_=None , lowerCAmelCase_=None , **lowerCAmelCase_ ): """simple docstring""" super().__init__(*lowerCAmelCase_ , **lowerCAmelCase_ ) _snake_case = eval_examples _snake_case = post_process_function def lowerCamelCase ( self , lowerCAmelCase_=None , lowerCAmelCase_=None , lowerCAmelCase_=None , lowerCAmelCase_ = "eval" ): """simple docstring""" _snake_case = self.eval_dataset if eval_dataset is None else eval_dataset _snake_case = self.get_eval_dataloader(lowerCAmelCase_ ) _snake_case = self.eval_examples if eval_examples is None else eval_examples # Temporarily disable metric computation, we will do it in the loop here. _snake_case = self.compute_metrics _snake_case = None _snake_case = self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop _snake_case = time.time() try: _snake_case = eval_loop( lowerCAmelCase_ , description='Evaluation' , prediction_loss_only=True if compute_metrics is None else None , ignore_keys=lowerCAmelCase_ , metric_key_prefix=lowerCAmelCase_ , ) finally: _snake_case = compute_metrics _snake_case = self.args.eval_batch_size * self.args.world_size if F'{metric_key_prefix}_jit_compilation_time' in output.metrics: start_time += output.metrics[F'{metric_key_prefix}_jit_compilation_time'] output.metrics.update( speed_metrics( lowerCAmelCase_ , lowerCAmelCase_ , num_samples=output.num_samples , num_steps=math.ceil(output.num_samples / total_batch_size ) , ) ) if self.post_process_function is not None and self.compute_metrics is not None and self.args.should_save: # Only the main node write the results by default _snake_case = self.post_process_function(lowerCAmelCase_ , lowerCAmelCase_ , output.predictions ) _snake_case = self.compute_metrics(lowerCAmelCase_ ) # Prefix all keys with metric_key_prefix + '_' for key in list(metrics.keys() ): if not key.startswith(F'{metric_key_prefix}_' ): _snake_case = metrics.pop(lowerCAmelCase_ ) metrics.update(output.metrics ) else: _snake_case = output.metrics if self.args.should_log: # Only the main node log the results by default self.log(lowerCAmelCase_ ) if self.args.tpu_metrics_debug or self.args.debug: # tpu-comment: Logging debug metrics for PyTorch/XLA (compile, execute times, ops, etc.) xm.master_print(met.metrics_report() ) _snake_case = self.callback_handler.on_evaluate(self.args , self.state , self.control , lowerCAmelCase_ ) return metrics def lowerCamelCase ( self , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_=None , lowerCAmelCase_ = "test" ): """simple docstring""" _snake_case = self.get_test_dataloader(lowerCAmelCase_ ) # Temporarily disable metric computation, we will do it in the loop here. _snake_case = self.compute_metrics _snake_case = None _snake_case = self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop _snake_case = time.time() try: _snake_case = eval_loop( lowerCAmelCase_ , description='Prediction' , prediction_loss_only=True if compute_metrics is None else None , ignore_keys=lowerCAmelCase_ , metric_key_prefix=lowerCAmelCase_ , ) finally: _snake_case = compute_metrics _snake_case = self.args.eval_batch_size * self.args.world_size if F'{metric_key_prefix}_jit_compilation_time' in output.metrics: start_time += output.metrics[F'{metric_key_prefix}_jit_compilation_time'] output.metrics.update( speed_metrics( lowerCAmelCase_ , lowerCAmelCase_ , num_samples=output.num_samples , num_steps=math.ceil(output.num_samples / total_batch_size ) , ) ) if self.post_process_function is None or self.compute_metrics is None: return output _snake_case = self.post_process_function(lowerCAmelCase_ , lowerCAmelCase_ , output.predictions , 'predict' ) _snake_case = self.compute_metrics(lowerCAmelCase_ ) # Prefix all keys with metric_key_prefix + '_' for key in list(metrics.keys() ): if not key.startswith(F'{metric_key_prefix}_' ): _snake_case = metrics.pop(lowerCAmelCase_ ) metrics.update(output.metrics ) return PredictionOutput(predictions=predictions.predictions , label_ids=predictions.label_ids , metrics=lowerCAmelCase_ )

'''simple docstring''' import enum import warnings from .. import MODEL_FOR_CAUSAL_LM_MAPPING, TF_MODEL_FOR_CAUSAL_LM_MAPPING from ..utils import add_end_docstrings, is_tf_available from .base import PIPELINE_INIT_ARGS, Pipeline if is_tf_available(): import tensorflow as tf class __A ( enum.Enum ): '''simple docstring''' __lowerCamelCase : Optional[int] = 0 __lowerCamelCase : Any = 1 __lowerCamelCase : List[Any] = 2 @add_end_docstrings(A ) class __A ( A ): '''simple docstring''' __lowerCamelCase : Dict = '\n In 1991, the remains of Russian Tsar Nicholas II and his family (except for Alexei and Maria) are discovered. The\n voice of Nicholas\'s young son, Tsarevich Alexei Nikolaevich, narrates the remainder of the story. 1883 Western\n Siberia, a young Grigori Rasputin is asked by his father and a group of men to perform magic. Rasputin has a vision\n and denounces one of the men as a horse thief. Although his father initially slaps him for making such an\n accusation, Rasputin watches as the man is chased outside and beaten. Twenty years later, Rasputin sees a vision of\n the Virgin Mary, prompting him to become a priest. Rasputin quickly becomes famous, with people, even a bishop,\n begging for his blessing. <eod> </s> <eos>\n ' def __init__(self , *A , **A ) -> Tuple: """simple docstring""" super().__init__(*A , **A ) self.check_model_type( TF_MODEL_FOR_CAUSAL_LM_MAPPING if self.framework == '''tf''' else MODEL_FOR_CAUSAL_LM_MAPPING ) if "prefix" not in self._preprocess_params: # This is very specific. The logic is quite complex and needs to be done # as a "default". # It also defines both some preprocess_kwargs and generate_kwargs # which is why we cannot put them in their respective methods. _a = None if self.model.config.prefix is not None: _a = self.model.config.prefix if prefix is None and self.model.__class__.__name__ in [ "XLNetLMHeadModel", "TransfoXLLMHeadModel", "TFXLNetLMHeadModel", "TFTransfoXLLMHeadModel", ]: # For XLNet and TransformerXL we add an article to the prompt to give more state to the model. _a = self.XL_PREFIX if prefix is not None: # Recalculate some generate_kwargs linked to prefix. _a , _a , _a = self._sanitize_parameters(prefix=A , **self._forward_params ) _a = {**self._preprocess_params, **preprocess_params} _a = {**self._forward_params, **forward_params} def a__ (self , A=None , A=None , A=None , A=None , A=None , A=None , A=None , A=None , **A , ) -> str: """simple docstring""" _a = {} if prefix is not None: _a = prefix if prefix: _a = self.tokenizer( A , padding=A , add_special_tokens=A , return_tensors=self.framework ) _a = prefix_inputs['''input_ids'''].shape[-1] if handle_long_generation is not None: if handle_long_generation not in {"hole"}: raise ValueError( f'''{handle_long_generation} is not a valid value for `handle_long_generation` parameter expected''' ''' [None, \'hole\']''' ) _a = handle_long_generation preprocess_params.update(A ) _a = generate_kwargs _a = {} if return_full_text is not None and return_type is None: if return_text is not None: raise ValueError('''`return_text` is mutually exclusive with `return_full_text`''' ) if return_tensors is not None: raise ValueError('''`return_full_text` is mutually exclusive with `return_tensors`''' ) _a = ReturnType.FULL_TEXT if return_full_text else ReturnType.NEW_TEXT if return_tensors is not None and return_type is None: if return_text is not None: raise ValueError('''`return_text` is mutually exclusive with `return_tensors`''' ) _a = ReturnType.TENSORS if return_type is not None: _a = return_type if clean_up_tokenization_spaces is not None: _a = clean_up_tokenization_spaces if stop_sequence is not None: _a = self.tokenizer.encode(A , add_special_tokens=A ) if len(A ) > 1: warnings.warn( '''Stopping on a multiple token sequence is not yet supported on transformers. The first token of''' ''' the stop sequence will be used as the stop sequence string in the interim.''' ) _a = stop_sequence_ids[0] return preprocess_params, forward_params, postprocess_params def a__ (self , *A , **A ) -> List[Any]: """simple docstring""" if self.model.__class__.__name__ in ["TransfoXLLMHeadModel"]: kwargs.update({'''add_space_before_punct_symbol''': True} ) return super()._parse_and_tokenize(*A , **A ) def __call__(self , A , **A ) -> int: """simple docstring""" return super().__call__(A , **A ) def a__ (self , A , A="" , A=None , **A ) -> Any: """simple docstring""" _a = self.tokenizer( prefix + prompt_text , padding=A , add_special_tokens=A , return_tensors=self.framework ) _a = prompt_text if handle_long_generation == "hole": _a = inputs['''input_ids'''].shape[-1] if "max_new_tokens" in generate_kwargs: _a = generate_kwargs['''max_new_tokens'''] else: _a = generate_kwargs.get('''max_length''' , self.model.config.max_length ) - cur_len if new_tokens < 0: raise ValueError('''We cannot infer how many new tokens are expected''' ) if cur_len + new_tokens > self.tokenizer.model_max_length: _a = self.tokenizer.model_max_length - new_tokens if keep_length <= 0: raise ValueError( '''We cannot use `hole` to handle this generation the number of desired tokens exceeds the''' ''' models max length''' ) _a = inputs['''input_ids'''][:, -keep_length:] if "attention_mask" in inputs: _a = inputs['''attention_mask'''][:, -keep_length:] return inputs def a__ (self , A , **A ) -> Any: """simple docstring""" _a = model_inputs['''input_ids'''] _a = model_inputs.get('''attention_mask''' , A ) # Allow empty prompts if input_ids.shape[1] == 0: _a = None _a = None _a = 1 else: _a = input_ids.shape[0] _a = model_inputs.pop('''prompt_text''' ) # If there is a prefix, we may need to adjust the generation length. Do so without permanently modifying # generate_kwargs, as some of the parameterization may come from the initialization of the pipeline. _a = generate_kwargs.pop('''prefix_length''' , 0 ) if prefix_length > 0: _a = '''max_new_tokens''' in generate_kwargs or ( '''generation_config''' in generate_kwargs and generate_kwargs['''generation_config'''].max_new_tokens is not None ) if not has_max_new_tokens: _a = generate_kwargs.get('''max_length''' ) or self.model.config.max_length generate_kwargs["max_length"] += prefix_length _a = '''min_new_tokens''' in generate_kwargs or ( '''generation_config''' in generate_kwargs and generate_kwargs['''generation_config'''].min_new_tokens is not None ) if not has_min_new_tokens and "min_length" in generate_kwargs: generate_kwargs["min_length"] += prefix_length # BS x SL _a = self.model.generate(input_ids=A , attention_mask=A , **A ) _a = generated_sequence.shape[0] if self.framework == "pt": _a = generated_sequence.reshape(A , out_b // in_b , *generated_sequence.shape[1:] ) elif self.framework == "tf": _a = tf.reshape(A , (in_b, out_b // in_b, *generated_sequence.shape[1:]) ) return {"generated_sequence": generated_sequence, "input_ids": input_ids, "prompt_text": prompt_text} def a__ (self , A , A=ReturnType.FULL_TEXT , A=True ) -> str: """simple docstring""" _a = model_outputs['''generated_sequence'''][0] _a = model_outputs['''input_ids'''] _a = model_outputs['''prompt_text'''] _a = generated_sequence.numpy().tolist() _a = [] for sequence in generated_sequence: if return_type == ReturnType.TENSORS: _a = {'''generated_token_ids''': sequence} elif return_type in {ReturnType.NEW_TEXT, ReturnType.FULL_TEXT}: # Decode text _a = self.tokenizer.decode( A , skip_special_tokens=A , clean_up_tokenization_spaces=A , ) # Remove PADDING prompt of the sequence if XLNet or Transfo-XL model is used if input_ids is None: _a = 0 else: _a = len( self.tokenizer.decode( input_ids[0] , skip_special_tokens=A , clean_up_tokenization_spaces=A , ) ) if return_type == ReturnType.FULL_TEXT: _a = prompt_text + text[prompt_length:] else: _a = text[prompt_length:] _a = {'''generated_text''': all_text} records.append(A ) return records

"""simple docstring""" import numpy as np import skfuzzy as fuzz if __name__ == "__main__": # Create universe of discourse in Python using linspace () __UpperCamelCase : List[Any] = np.linspace(start=0, stop=75, num=75, endpoint=True, retstep=False) # Create two fuzzy sets by defining any membership function # (trapmf(), gbellmf(), gaussmf(), etc). __UpperCamelCase : str = [0, 25, 50] __UpperCamelCase : int = [25, 50, 75] __UpperCamelCase : str = fuzz.membership.trimf(X, abca) __UpperCamelCase : Tuple = fuzz.membership.trimf(X, abca) # Compute the different operations using inbuilt functions. __UpperCamelCase : Dict = np.ones(75) __UpperCamelCase : str = np.zeros((75,)) # 1. Union = max(µA(x), µB(x)) __UpperCamelCase : Optional[Any] = fuzz.fuzzy_or(X, young, X, middle_aged)[1] # 2. Intersection = min(µA(x), µB(x)) __UpperCamelCase : Dict = fuzz.fuzzy_and(X, young, X, middle_aged)[1] # 3. Complement (A) = (1- min(µA(x)) __UpperCamelCase : Dict = fuzz.fuzzy_not(young) # 4. Difference (A/B) = min(µA(x),(1- µB(x))) __UpperCamelCase : List[str] = fuzz.fuzzy_and(X, young, X, fuzz.fuzzy_not(middle_aged)[1])[1] # 5. Algebraic Sum = [µA(x) + µB(x) – (µA(x) * µB(x))] __UpperCamelCase : List[str] = young + middle_aged - (young * middle_aged) # 6. Algebraic Product = (µA(x) * µB(x)) __UpperCamelCase : Tuple = young * middle_aged # 7. Bounded Sum = min[1,(µA(x), µB(x))] __UpperCamelCase : Union[str, Any] = fuzz.fuzzy_and(X, one, X, young + middle_aged)[1] # 8. Bounded difference = min[0,(µA(x), µB(x))] __UpperCamelCase : Dict = fuzz.fuzzy_or(X, zero, X, young - middle_aged)[1] # max-min composition # max-product composition # Plot each set A, set B and each operation result using plot() and subplot(). from matplotlib import pyplot as plt plt.figure() plt.subplot(4, 3, 1) plt.plot(X, young) plt.title('''Young''') plt.grid(True) plt.subplot(4, 3, 2) plt.plot(X, middle_aged) plt.title('''Middle aged''') plt.grid(True) plt.subplot(4, 3, 3) plt.plot(X, union) plt.title('''union''') plt.grid(True) plt.subplot(4, 3, 4) plt.plot(X, intersection) plt.title('''intersection''') plt.grid(True) plt.subplot(4, 3, 5) plt.plot(X, complement_a) plt.title('''complement_a''') plt.grid(True) plt.subplot(4, 3, 6) plt.plot(X, difference) plt.title('''difference a/b''') plt.grid(True) plt.subplot(4, 3, 7) plt.plot(X, alg_sum) plt.title('''alg_sum''') plt.grid(True) plt.subplot(4, 3, 8) plt.plot(X, alg_product) plt.title('''alg_product''') plt.grid(True) plt.subplot(4, 3, 9) plt.plot(X, bdd_sum) plt.title('''bdd_sum''') plt.grid(True) plt.subplot(4, 3, 10) plt.plot(X, bdd_difference) plt.title('''bdd_difference''') plt.grid(True) plt.subplots_adjust(hspace=0.5) plt.show()

"""simple docstring""" import pytest from datasets.splits import SplitDict, SplitInfo from datasets.utils.py_utils import asdict @pytest.mark.parametrize( 'split_dict' , [ SplitDict(), SplitDict({'train': SplitInfo(name='train' , num_bytes=1337 , num_examples=42 , dataset_name='my_dataset' )} ), SplitDict({'train': SplitInfo(name='train' , num_bytes=1337 , num_examples=42 )} ), SplitDict({'train': SplitInfo()} ), ] , ) def _SCREAMING_SNAKE_CASE (_UpperCAmelCase : SplitDict ): lowerCAmelCase = split_dict._to_yaml_list() assert len(_UpperCAmelCase ) == len(_UpperCAmelCase ) lowerCAmelCase = SplitDict._from_yaml_list(_UpperCAmelCase ) for split_name, split_info in split_dict.items(): # dataset_name field is deprecated, and is therefore not part of the YAML dump lowerCAmelCase = None # the split name of split_dict takes over the name of the split info object lowerCAmelCase = split_name assert split_dict == reloaded @pytest.mark.parametrize( 'split_info' , [SplitInfo(), SplitInfo(dataset_name=_UpperCAmelCase ), SplitInfo(dataset_name='my_dataset' )] ) def _SCREAMING_SNAKE_CASE (_UpperCAmelCase : List[str] ): # For backward compatibility, we need asdict(split_dict) to return split info dictrionaries with the "dataset_name" # field even if it's deprecated. This way old versionso of `datasets` can still reload dataset_infos.json files lowerCAmelCase = asdict(SplitDict({'train': split_info} ) ) assert "dataset_name" in split_dict_asdict["train"] assert split_dict_asdict["train"]["dataset_name"] == split_info.dataset_name

from typing import Dict, Optional import numpy as np import datasets SCREAMING_SNAKE_CASE :List[Any] = '\nIoU is the area of overlap between the predicted segmentation and the ground truth divided by the area of union\nbetween the predicted segmentation and the ground truth. For binary (two classes) or multi-class segmentation,\nthe mean IoU of the image is calculated by taking the IoU of each class and averaging them.\n' SCREAMING_SNAKE_CASE :List[str] = '\nArgs:\n predictions (`List[ndarray]`):\n List of predicted segmentation maps, each of shape (height, width). Each segmentation map can be of a different size.\n references (`List[ndarray]`):\n List of ground truth segmentation maps, each of shape (height, width). Each segmentation map can be of a different size.\n num_labels (`int`):\n Number of classes (categories).\n ignore_index (`int`):\n Index that will be ignored during evaluation.\n nan_to_num (`int`, *optional*):\n If specified, NaN values will be replaced by the number defined by the user.\n label_map (`dict`, *optional*):\n If specified, dictionary mapping old label indices to new label indices.\n reduce_labels (`bool`, *optional*, defaults to `False`):\n Whether or not to reduce all label values of segmentation maps by 1. Usually used for datasets where 0 is used for background,\n and background itself is not included in all classes of a dataset (e.g. ADE20k). The background label will be replaced by 255.\n\nReturns:\n `Dict[str, float | ndarray]` comprising various elements:\n - *mean_iou* (`float`):\n Mean Intersection-over-Union (IoU averaged over all categories).\n - *mean_accuracy* (`float`):\n Mean accuracy (averaged over all categories).\n - *overall_accuracy* (`float`):\n Overall accuracy on all images.\n - *per_category_accuracy* (`ndarray` of shape `(num_labels,)`):\n Per category accuracy.\n - *per_category_iou* (`ndarray` of shape `(num_labels,)`):\n Per category IoU.\n\nExamples:\n\n >>> import numpy as np\n\n >>> mean_iou = datasets.load_metric("mean_iou")\n\n >>> # suppose one has 3 different segmentation maps predicted\n >>> predicted_1 = np.array([[1, 2], [3, 4], [5, 255]])\n >>> actual_1 = np.array([[0, 3], [5, 4], [6, 255]])\n\n >>> predicted_2 = np.array([[2, 7], [9, 2], [3, 6]])\n >>> actual_2 = np.array([[1, 7], [9, 2], [3, 6]])\n\n >>> predicted_3 = np.array([[2, 2, 3], [8, 2, 4], [3, 255, 2]])\n >>> actual_3 = np.array([[1, 2, 2], [8, 2, 1], [3, 255, 1]])\n\n >>> predicted = [predicted_1, predicted_2, predicted_3]\n >>> ground_truth = [actual_1, actual_2, actual_3]\n\n >>> results = mean_iou.compute(predictions=predicted, references=ground_truth, num_labels=10, ignore_index=255, reduce_labels=False)\n >>> print(results) # doctest: +NORMALIZE_WHITESPACE\n {\'mean_iou\': 0.47750000000000004, \'mean_accuracy\': 0.5916666666666666, \'overall_accuracy\': 0.5263157894736842, \'per_category_iou\': array([0. , 0. , 0.375, 0.4 , 0.5 , 0. , 0.5 , 1. , 1. , 1. ]), \'per_category_accuracy\': array([0. , 0. , 0.75 , 0.66666667, 1. , 0. , 0.5 , 1. , 1. , 1. ])}\n' SCREAMING_SNAKE_CASE :str = '\\n@software{MMSegmentation_Contributors_OpenMMLab_Semantic_Segmentation_2020,\nauthor = {{MMSegmentation Contributors}},\nlicense = {Apache-2.0},\nmonth = {7},\ntitle = {{OpenMMLab Semantic Segmentation Toolbox and Benchmark}},\nurl = {https://github.com/open-mmlab/mmsegmentation},\nyear = {2020}\n}' def UpperCAmelCase ( a_ , a_ , a_ , a_ , a_ = None , a_ = False , ) -> Tuple: """simple docstring""" if label_map is not None: for old_id, new_id in label_map.items(): __A = new_id # turn into Numpy arrays __A = np.array(a_ ) __A = np.array(a_ ) if reduce_labels: __A = 2_5_5 __A = label - 1 __A = 2_5_5 __A = label != ignore_index __A = np.not_equal(a_ , a_ ) __A = pred_label[mask] __A = np.array(a_ )[mask] __A = pred_label[pred_label == label] __A = np.histogram(a_ , bins=a_ , range=(0, num_labels - 1) )[0] __A = np.histogram(a_ , bins=a_ , range=(0, num_labels - 1) )[0] __A = np.histogram(a_ , bins=a_ , range=(0, num_labels - 1) )[0] __A = area_pred_label + area_label - area_intersect return area_intersect, area_union, area_pred_label, area_label def UpperCAmelCase ( a_ , a_ , a_ , a_ , a_ = None , a_ = False , ) -> Union[str, Any]: """simple docstring""" __A = np.zeros((num_labels,) , dtype=np.floataa ) __A = np.zeros((num_labels,) , dtype=np.floataa ) __A = np.zeros((num_labels,) , dtype=np.floataa ) __A = np.zeros((num_labels,) , dtype=np.floataa ) for result, gt_seg_map in zip(a_ , a_ ): __A , __A , __A , __A = intersect_and_union( a_ , a_ , a_ , a_ , a_ , a_ ) total_area_intersect += area_intersect total_area_union += area_union total_area_pred_label += area_pred_label total_area_label += area_label return total_area_intersect, total_area_union, total_area_pred_label, total_area_label def UpperCAmelCase ( a_ , a_ , a_ , a_ , a_ = None , a_ = None , a_ = False , ) -> str: """simple docstring""" __A , __A , __A , __A = total_intersect_and_union( a_ , a_ , a_ , a_ , a_ , a_ ) # compute metrics __A = {} __A = total_area_intersect.sum() / total_area_label.sum() __A = total_area_intersect / total_area_union __A = total_area_intersect / total_area_label __A = np.nanmean(a_ ) __A = np.nanmean(a_ ) __A = all_acc __A = iou __A = acc if nan_to_num is not None: __A = {metric: np.nan_to_num(a_ , nan=a_ ) for metric, metric_value in metrics.items()} return metrics @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class UpperCAmelCase ( datasets.Metric ): '''simple docstring''' def UpperCamelCase_ ( self : List[Any] ): return datasets.MetricInfo( description=_DESCRIPTION ,citation=_CITATION ,inputs_description=_KWARGS_DESCRIPTION ,features=datasets.Features( # 1st Seq - height dim, 2nd - width dim { "predictions": datasets.Sequence(datasets.Sequence(datasets.Value("uint16" ) ) ), "references": datasets.Sequence(datasets.Sequence(datasets.Value("uint16" ) ) ), } ) ,reference_urls=[ "https://github.com/open-mmlab/mmsegmentation/blob/71c201b1813267d78764f306a297ca717827c4bf/mmseg/core/evaluation/metrics.py" ] ,) def UpperCamelCase_ ( self : int ,A : Optional[Any] ,A : Optional[Any] ,A : int ,A : bool ,A : Optional[int] = None ,A : Optional[Dict[int, int]] = None ,A : bool = False ,): __A = mean_iou( results=A ,gt_seg_maps=A ,num_labels=A ,ignore_index=A ,nan_to_num=A ,label_map=A ,reduce_labels=A ,) return iou_result

"""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__ : str = logging.get_logger(__name__) UpperCAmelCase__ : Optional[int] = { 'hustvl/yolos-small': 'https://huggingface.co/hustvl/yolos-small/resolve/main/config.json', # See all YOLOS models at https://huggingface.co/models?filter=yolos } class lowerCAmelCase_ (a__ ): """simple docstring""" __UpperCamelCase : int = '''yolos''' def __init__(self , SCREAMING_SNAKE_CASE__=7_68 , SCREAMING_SNAKE_CASE__=12 , SCREAMING_SNAKE_CASE__=12 , SCREAMING_SNAKE_CASE__=30_72 , SCREAMING_SNAKE_CASE__="gelu" , SCREAMING_SNAKE_CASE__=0.0 , SCREAMING_SNAKE_CASE__=0.0 , SCREAMING_SNAKE_CASE__=0.02 , SCREAMING_SNAKE_CASE__=1E-12 , SCREAMING_SNAKE_CASE__=[5_12, 8_64] , SCREAMING_SNAKE_CASE__=16 , SCREAMING_SNAKE_CASE__=3 , SCREAMING_SNAKE_CASE__=True , SCREAMING_SNAKE_CASE__=1_00 , SCREAMING_SNAKE_CASE__=True , SCREAMING_SNAKE_CASE__=False , SCREAMING_SNAKE_CASE__=1 , SCREAMING_SNAKE_CASE__=5 , SCREAMING_SNAKE_CASE__=2 , SCREAMING_SNAKE_CASE__=5 , SCREAMING_SNAKE_CASE__=2 , SCREAMING_SNAKE_CASE__=0.1 , **SCREAMING_SNAKE_CASE__ , ) -> Optional[Any]: """simple docstring""" super().__init__(**SCREAMING_SNAKE_CASE__ ) SCREAMING_SNAKE_CASE__ : Optional[int] = hidden_size SCREAMING_SNAKE_CASE__ : int = num_hidden_layers SCREAMING_SNAKE_CASE__ : str = num_attention_heads SCREAMING_SNAKE_CASE__ : List[str] = intermediate_size SCREAMING_SNAKE_CASE__ : Optional[Any] = hidden_act SCREAMING_SNAKE_CASE__ : List[Any] = hidden_dropout_prob SCREAMING_SNAKE_CASE__ : Optional[Any] = attention_probs_dropout_prob SCREAMING_SNAKE_CASE__ : Optional[int] = 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__ : List[str] = num_channels SCREAMING_SNAKE_CASE__ : List[str] = qkv_bias SCREAMING_SNAKE_CASE__ : Optional[int] = num_detection_tokens SCREAMING_SNAKE_CASE__ : Optional[Any] = use_mid_position_embeddings SCREAMING_SNAKE_CASE__ : List[str] = auxiliary_loss # Hungarian matcher SCREAMING_SNAKE_CASE__ : Optional[Any] = class_cost SCREAMING_SNAKE_CASE__ : List[str] = bbox_cost SCREAMING_SNAKE_CASE__ : List[Any] = giou_cost # Loss coefficients SCREAMING_SNAKE_CASE__ : Optional[Any] = bbox_loss_coefficient SCREAMING_SNAKE_CASE__ : List[str] = giou_loss_coefficient SCREAMING_SNAKE_CASE__ : int = eos_coefficient class lowerCAmelCase_ (a__ ): """simple docstring""" __UpperCamelCase : Dict = version.parse('''1.11''' ) @property def __magic_name__ (self ) -> Mapping[str, Mapping[int, str]]: """simple docstring""" return OrderedDict( [ ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}), ] ) @property def __magic_name__ (self ) -> float: """simple docstring""" return 1E-4 @property def __magic_name__ (self ) -> int: """simple docstring""" return 12

import contextlib import csv import json import os import sqlitea import tarfile import textwrap import zipfile import pyarrow as pa import pyarrow.parquet as pq import pytest import datasets import datasets.config @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( ): '''simple docstring''' UpperCamelCase__ = 10 UpperCamelCase__ = datasets.Features( { '''tokens''': datasets.Sequence(datasets.Value('''string''' ) ), '''labels''': datasets.Sequence(datasets.ClassLabel(names=['''negative''', '''positive'''] ) ), '''answers''': datasets.Sequence( { '''text''': datasets.Value('''string''' ), '''answer_start''': datasets.Value('''int32''' ), } ), '''id''': datasets.Value('''int64''' ), } ) UpperCamelCase__ = datasets.Dataset.from_dict( { '''tokens''': [['''foo'''] * 5] * n, '''labels''': [[1] * 5] * n, '''answers''': [{'''answer_start''': [97], '''text''': ['''1976''']}] * 10, '''id''': list(range(UpperCamelCase__ ) ), }, features=UpperCamelCase__, ) return dataset @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : Optional[int], UpperCamelCase__ : str ): '''simple docstring''' UpperCamelCase__ = str(tmp_path_factory.mktemp('''data''' ) / '''file.arrow''' ) dataset.map(cache_file_name=UpperCamelCase__ ) return filename # FILE_CONTENT + files lowercase = """\ Text data. Second line of data.""" @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : List[Any] ): '''simple docstring''' UpperCamelCase__ = tmp_path_factory.mktemp('''data''' ) / '''file.txt''' UpperCamelCase__ = FILE_CONTENT with open(UpperCamelCase__, '''w''' ) as f: f.write(UpperCamelCase__ ) return filename @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : Optional[int] ): '''simple docstring''' import bza UpperCamelCase__ = tmp_path_factory.mktemp('''data''' ) / '''file.txt.bz2''' UpperCamelCase__ = bytes(UpperCamelCase__, '''utf-8''' ) with bza.open(UpperCamelCase__, '''wb''' ) as f: f.write(UpperCamelCase__ ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : Dict ): '''simple docstring''' import gzip UpperCamelCase__ = str(tmp_path_factory.mktemp('''data''' ) / '''file.txt.gz''' ) UpperCamelCase__ = bytes(UpperCamelCase__, '''utf-8''' ) with gzip.open(UpperCamelCase__, '''wb''' ) as f: f.write(UpperCamelCase__ ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : Tuple ): '''simple docstring''' if datasets.config.LZ4_AVAILABLE: import lza.frame UpperCamelCase__ = tmp_path_factory.mktemp('''data''' ) / '''file.txt.lz4''' UpperCamelCase__ = bytes(UpperCamelCase__, '''utf-8''' ) with lza.frame.open(UpperCamelCase__, '''wb''' ) as f: f.write(UpperCamelCase__ ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : Tuple, UpperCamelCase__ : Optional[Any] ): '''simple docstring''' if datasets.config.PY7ZR_AVAILABLE: import pyazr UpperCamelCase__ = tmp_path_factory.mktemp('''data''' ) / '''file.txt.7z''' with pyazr.SevenZipFile(UpperCamelCase__, '''w''' ) as archive: archive.write(UpperCamelCase__, arcname=os.path.basename(UpperCamelCase__ ) ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : str, UpperCamelCase__ : Dict ): '''simple docstring''' import tarfile UpperCamelCase__ = tmp_path_factory.mktemp('''data''' ) / '''file.txt.tar''' with tarfile.TarFile(UpperCamelCase__, '''w''' ) as f: f.add(UpperCamelCase__, arcname=os.path.basename(UpperCamelCase__ ) ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : str ): '''simple docstring''' import lzma UpperCamelCase__ = tmp_path_factory.mktemp('''data''' ) / '''file.txt.xz''' UpperCamelCase__ = bytes(UpperCamelCase__, '''utf-8''' ) with lzma.open(UpperCamelCase__, '''wb''' ) as f: f.write(UpperCamelCase__ ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : int, UpperCamelCase__ : List[Any] ): '''simple docstring''' import zipfile UpperCamelCase__ = tmp_path_factory.mktemp('''data''' ) / '''file.txt.zip''' with zipfile.ZipFile(UpperCamelCase__, '''w''' ) as f: f.write(UpperCamelCase__, arcname=os.path.basename(UpperCamelCase__ ) ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : Tuple ): '''simple docstring''' if datasets.config.ZSTANDARD_AVAILABLE: import zstandard as zstd UpperCamelCase__ = tmp_path_factory.mktemp('''data''' ) / '''file.txt.zst''' UpperCamelCase__ = bytes(UpperCamelCase__, '''utf-8''' ) with zstd.open(UpperCamelCase__, '''wb''' ) as f: f.write(UpperCamelCase__ ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : int ): '''simple docstring''' UpperCamelCase__ = tmp_path_factory.mktemp('''data''' ) / '''file.xml''' UpperCamelCase__ = textwrap.dedent( '''\ <?xml version="1.0" encoding="UTF-8" ?> <tmx version="1.4"> <header segtype="sentence" srclang="ca" /> <body> <tu> <tuv xml:lang="ca"><seg>Contingut 1</seg></tuv> <tuv xml:lang="en"><seg>Content 1</seg></tuv> </tu> <tu> <tuv xml:lang="ca"><seg>Contingut 2</seg></tuv> <tuv xml:lang="en"><seg>Content 2</seg></tuv> </tu> <tu> <tuv xml:lang="ca"><seg>Contingut 3</seg></tuv> <tuv xml:lang="en"><seg>Content 3</seg></tuv> </tu> <tu> <tuv xml:lang="ca"><seg>Contingut 4</seg></tuv> <tuv xml:lang="en"><seg>Content 4</seg></tuv> </tu> <tu> <tuv xml:lang="ca"><seg>Contingut 5</seg></tuv> <tuv xml:lang="en"><seg>Content 5</seg></tuv> </tu> </body> </tmx>''' ) with open(UpperCamelCase__, '''w''' ) as f: f.write(UpperCamelCase__ ) return filename lowercase = [ {"""col_1""": """0""", """col_2""": 0, """col_3""": 0.0}, {"""col_1""": """1""", """col_2""": 1, """col_3""": 1.0}, {"""col_1""": """2""", """col_2""": 2, """col_3""": 2.0}, {"""col_1""": """3""", """col_2""": 3, """col_3""": 3.0}, ] lowercase = [ {"""col_1""": """4""", """col_2""": 4, """col_3""": 4.0}, {"""col_1""": """5""", """col_2""": 5, """col_3""": 5.0}, ] lowercase = { """col_1""": ["""0""", """1""", """2""", """3"""], """col_2""": [0, 1, 2, 3], """col_3""": [0.0, 1.0, 2.0, 3.0], } lowercase = [ {"""col_3""": 0.0, """col_1""": """0""", """col_2""": 0}, {"""col_3""": 1.0, """col_1""": """1""", """col_2""": 1}, ] lowercase = [ {"""col_1""": """s0""", """col_2""": 0, """col_3""": 0.0}, {"""col_1""": """s1""", """col_2""": 1, """col_3""": 1.0}, {"""col_1""": """s2""", """col_2""": 2, """col_3""": 2.0}, {"""col_1""": """s3""", """col_2""": 3, """col_3""": 3.0}, ] @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( ): '''simple docstring''' return DATA_DICT_OF_LISTS @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : List[Any] ): '''simple docstring''' UpperCamelCase__ = datasets.Dataset.from_dict(UpperCamelCase__ ) UpperCamelCase__ = str(tmp_path_factory.mktemp('''data''' ) / '''dataset.arrow''' ) dataset.map(cache_file_name=UpperCamelCase__ ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : int ): '''simple docstring''' UpperCamelCase__ = str(tmp_path_factory.mktemp('''data''' ) / '''dataset.sqlite''' ) with contextlib.closing(sqlitea.connect(UpperCamelCase__ ) ) as con: UpperCamelCase__ = con.cursor() cur.execute('''CREATE TABLE dataset(col_1 text, col_2 int, col_3 real)''' ) for item in DATA: cur.execute('''INSERT INTO dataset(col_1, col_2, col_3) VALUES (?, ?, ?)''', tuple(item.values() ) ) con.commit() return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : int ): '''simple docstring''' UpperCamelCase__ = str(tmp_path_factory.mktemp('''data''' ) / '''dataset.csv''' ) with open(UpperCamelCase__, '''w''', newline='''''' ) as f: UpperCamelCase__ = csv.DictWriter(UpperCamelCase__, fieldnames=['''col_1''', '''col_2''', '''col_3'''] ) writer.writeheader() for item in DATA: writer.writerow(UpperCamelCase__ ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : int ): '''simple docstring''' UpperCamelCase__ = str(tmp_path_factory.mktemp('''data''' ) / '''dataset2.csv''' ) with open(UpperCamelCase__, '''w''', newline='''''' ) as f: UpperCamelCase__ = csv.DictWriter(UpperCamelCase__, fieldnames=['''col_1''', '''col_2''', '''col_3'''] ) writer.writeheader() for item in DATA: writer.writerow(UpperCamelCase__ ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : Union[str, Any], UpperCamelCase__ : Union[str, Any] ): '''simple docstring''' import bza UpperCamelCase__ = tmp_path_factory.mktemp('''data''' ) / '''dataset.csv.bz2''' with open(UpperCamelCase__, '''rb''' ) as f: UpperCamelCase__ = f.read() # data = bytes(FILE_CONTENT, "utf-8") with bza.open(UpperCamelCase__, '''wb''' ) as f: f.write(UpperCamelCase__ ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : Tuple, UpperCamelCase__ : Optional[Any], UpperCamelCase__ : int ): '''simple docstring''' UpperCamelCase__ = tmp_path_factory.mktemp('''data''' ) / '''dataset.csv.zip''' with zipfile.ZipFile(UpperCamelCase__, '''w''' ) as f: f.write(UpperCamelCase__, arcname=os.path.basename(UpperCamelCase__ ) ) f.write(UpperCamelCase__, arcname=os.path.basename(UpperCamelCase__ ) ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : Any, UpperCamelCase__ : List[Any], UpperCamelCase__ : Optional[Any] ): '''simple docstring''' UpperCamelCase__ = tmp_path_factory.mktemp('''data''' ) / '''dataset.csv.zip''' with zipfile.ZipFile(UpperCamelCase__, '''w''' ) as f: f.write(UpperCamelCase__, arcname=os.path.basename(csv_path.replace('''.csv''', '''.CSV''' ) ) ) f.write(UpperCamelCase__, arcname=os.path.basename(csva_path.replace('''.csv''', '''.CSV''' ) ) ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : Optional[int], UpperCamelCase__ : Tuple, UpperCamelCase__ : Optional[int] ): '''simple docstring''' UpperCamelCase__ = tmp_path_factory.mktemp('''data''' ) / '''dataset_with_dir.csv.zip''' with zipfile.ZipFile(UpperCamelCase__, '''w''' ) as f: f.write(UpperCamelCase__, arcname=os.path.join('''main_dir''', os.path.basename(UpperCamelCase__ ) ) ) f.write(UpperCamelCase__, arcname=os.path.join('''main_dir''', os.path.basename(UpperCamelCase__ ) ) ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : int ): '''simple docstring''' UpperCamelCase__ = str(tmp_path_factory.mktemp('''data''' ) / '''dataset.parquet''' ) UpperCamelCase__ = pa.schema( { '''col_1''': pa.string(), '''col_2''': pa.intaa(), '''col_3''': pa.floataa(), } ) with open(UpperCamelCase__, '''wb''' ) as f: UpperCamelCase__ = pq.ParquetWriter(UpperCamelCase__, schema=UpperCamelCase__ ) UpperCamelCase__ = pa.Table.from_pydict({k: [DATA[i][k] for i in range(len(UpperCamelCase__ ) )] for k in DATA[0]}, schema=UpperCamelCase__ ) writer.write_table(UpperCamelCase__ ) writer.close() return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : List[str] ): '''simple docstring''' UpperCamelCase__ = str(tmp_path_factory.mktemp('''data''' ) / '''dataset.json''' ) UpperCamelCase__ = {'''data''': DATA} with open(UpperCamelCase__, '''w''' ) as f: json.dump(UpperCamelCase__, UpperCamelCase__ ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : int ): '''simple docstring''' UpperCamelCase__ = str(tmp_path_factory.mktemp('''data''' ) / '''dataset.json''' ) UpperCamelCase__ = {'''data''': DATA_DICT_OF_LISTS} with open(UpperCamelCase__, '''w''' ) as f: json.dump(UpperCamelCase__, UpperCamelCase__ ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : Any ): '''simple docstring''' UpperCamelCase__ = str(tmp_path_factory.mktemp('''data''' ) / '''dataset.jsonl''' ) with open(UpperCamelCase__, '''w''' ) as f: for item in DATA: f.write(json.dumps(UpperCamelCase__ ) + '''\n''' ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : Union[str, Any] ): '''simple docstring''' UpperCamelCase__ = str(tmp_path_factory.mktemp('''data''' ) / '''dataset2.jsonl''' ) with open(UpperCamelCase__, '''w''' ) as f: for item in DATA: f.write(json.dumps(UpperCamelCase__ ) + '''\n''' ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : Any ): '''simple docstring''' UpperCamelCase__ = str(tmp_path_factory.mktemp('''data''' ) / '''dataset_312.jsonl''' ) with open(UpperCamelCase__, '''w''' ) as f: for item in DATA_312: f.write(json.dumps(UpperCamelCase__ ) + '''\n''' ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : List[Any] ): '''simple docstring''' UpperCamelCase__ = str(tmp_path_factory.mktemp('''data''' ) / '''dataset-str.jsonl''' ) with open(UpperCamelCase__, '''w''' ) as f: for item in DATA_STR: f.write(json.dumps(UpperCamelCase__ ) + '''\n''' ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : Optional[int], UpperCamelCase__ : List[str] ): '''simple docstring''' import gzip UpperCamelCase__ = str(tmp_path_factory.mktemp('''data''' ) / '''dataset.txt.gz''' ) with open(UpperCamelCase__, '''rb''' ) as orig_file: with gzip.open(UpperCamelCase__, '''wb''' ) as zipped_file: zipped_file.writelines(UpperCamelCase__ ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : Tuple, UpperCamelCase__ : Tuple ): '''simple docstring''' import gzip UpperCamelCase__ = str(tmp_path_factory.mktemp('''data''' ) / '''dataset.jsonl.gz''' ) with open(UpperCamelCase__, '''rb''' ) as orig_file: with gzip.open(UpperCamelCase__, '''wb''' ) as zipped_file: zipped_file.writelines(UpperCamelCase__ ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : Union[str, Any], UpperCamelCase__ : Optional[Any], UpperCamelCase__ : Optional[int] ): '''simple docstring''' UpperCamelCase__ = tmp_path_factory.mktemp('''data''' ) / '''dataset.jsonl.zip''' with zipfile.ZipFile(UpperCamelCase__, '''w''' ) as f: f.write(UpperCamelCase__, arcname=os.path.basename(UpperCamelCase__ ) ) f.write(UpperCamelCase__, arcname=os.path.basename(UpperCamelCase__ ) ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : str, UpperCamelCase__ : str, UpperCamelCase__ : Dict, UpperCamelCase__ : Optional[int] ): '''simple docstring''' UpperCamelCase__ = tmp_path_factory.mktemp('''data''' ) / '''dataset_nested.jsonl.zip''' with zipfile.ZipFile(UpperCamelCase__, '''w''' ) as f: f.write(UpperCamelCase__, arcname=os.path.join('''nested''', os.path.basename(UpperCamelCase__ ) ) ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : Union[str, Any], UpperCamelCase__ : Optional[Any], UpperCamelCase__ : Dict ): '''simple docstring''' UpperCamelCase__ = tmp_path_factory.mktemp('''data''' ) / '''dataset_with_dir.jsonl.zip''' with zipfile.ZipFile(UpperCamelCase__, '''w''' ) as f: f.write(UpperCamelCase__, arcname=os.path.join('''main_dir''', os.path.basename(UpperCamelCase__ ) ) ) f.write(UpperCamelCase__, arcname=os.path.join('''main_dir''', os.path.basename(UpperCamelCase__ ) ) ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : List[Any], UpperCamelCase__ : List[Any], UpperCamelCase__ : Optional[Any] ): '''simple docstring''' UpperCamelCase__ = tmp_path_factory.mktemp('''data''' ) / '''dataset.jsonl.tar''' with tarfile.TarFile(UpperCamelCase__, '''w''' ) as f: f.add(UpperCamelCase__, arcname=os.path.basename(UpperCamelCase__ ) ) f.add(UpperCamelCase__, arcname=os.path.basename(UpperCamelCase__ ) ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : List[Any], UpperCamelCase__ : List[Any], UpperCamelCase__ : int, UpperCamelCase__ : Any ): '''simple docstring''' UpperCamelCase__ = tmp_path_factory.mktemp('''data''' ) / '''dataset_nested.jsonl.tar''' with tarfile.TarFile(UpperCamelCase__, '''w''' ) as f: f.add(UpperCamelCase__, arcname=os.path.join('''nested''', os.path.basename(UpperCamelCase__ ) ) ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : Tuple ): '''simple docstring''' UpperCamelCase__ = ['''0''', '''1''', '''2''', '''3'''] UpperCamelCase__ = str(tmp_path_factory.mktemp('''data''' ) / '''dataset.txt''' ) with open(UpperCamelCase__, '''w''' ) as f: for item in data: f.write(item + '''\n''' ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : Dict ): '''simple docstring''' UpperCamelCase__ = ['''0''', '''1''', '''2''', '''3'''] UpperCamelCase__ = str(tmp_path_factory.mktemp('''data''' ) / '''dataset2.txt''' ) with open(UpperCamelCase__, '''w''' ) as f: for item in data: f.write(item + '''\n''' ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : Dict ): '''simple docstring''' UpperCamelCase__ = ['''0''', '''1''', '''2''', '''3'''] UpperCamelCase__ = tmp_path_factory.mktemp('''data''' ) / '''dataset.abc''' with open(UpperCamelCase__, '''w''' ) as f: for item in data: f.write(item + '''\n''' ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : List[str], UpperCamelCase__ : Optional[Any], UpperCamelCase__ : str ): '''simple docstring''' UpperCamelCase__ = tmp_path_factory.mktemp('''data''' ) / '''dataset.text.zip''' with zipfile.ZipFile(UpperCamelCase__, '''w''' ) as f: f.write(UpperCamelCase__, arcname=os.path.basename(UpperCamelCase__ ) ) f.write(UpperCamelCase__, arcname=os.path.basename(UpperCamelCase__ ) ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : int, UpperCamelCase__ : int, UpperCamelCase__ : List[str] ): '''simple docstring''' UpperCamelCase__ = tmp_path_factory.mktemp('''data''' ) / '''dataset_with_dir.text.zip''' with zipfile.ZipFile(UpperCamelCase__, '''w''' ) as f: f.write(UpperCamelCase__, arcname=os.path.join('''main_dir''', os.path.basename(UpperCamelCase__ ) ) ) f.write(UpperCamelCase__, arcname=os.path.join('''main_dir''', os.path.basename(UpperCamelCase__ ) ) ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : int, UpperCamelCase__ : Tuple, UpperCamelCase__ : Union[str, Any] ): '''simple docstring''' UpperCamelCase__ = tmp_path_factory.mktemp('''data''' ) / '''dataset.ext.zip''' with zipfile.ZipFile(UpperCamelCase__, '''w''' ) as f: f.write(UpperCamelCase__, arcname=os.path.basename('''unsupported.ext''' ) ) f.write(UpperCamelCase__, arcname=os.path.basename('''unsupported_2.ext''' ) ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : int ): '''simple docstring''' UpperCamelCase__ = '''\n'''.join(['''First''', '''Second\u2029with Unicode new line''', '''Third'''] ) UpperCamelCase__ = str(tmp_path_factory.mktemp('''data''' ) / '''dataset_with_unicode_new_lines.txt''' ) with open(UpperCamelCase__, '''w''', encoding='''utf-8''' ) as f: f.write(UpperCamelCase__ ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( ): '''simple docstring''' return os.path.join('''tests''', '''features''', '''data''', '''test_image_rgb.jpg''' ) @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( ): '''simple docstring''' return os.path.join('''tests''', '''features''', '''data''', '''test_audio_44100.wav''' ) @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : Any, UpperCamelCase__ : Any ): '''simple docstring''' UpperCamelCase__ = tmp_path_factory.mktemp('''data''' ) / '''dataset.img.zip''' with zipfile.ZipFile(UpperCamelCase__, '''w''' ) as f: f.write(UpperCamelCase__, arcname=os.path.basename(UpperCamelCase__ ) ) f.write(UpperCamelCase__, arcname=os.path.basename(UpperCamelCase__ ).replace('''.jpg''', '''2.jpg''' ) ) return path @pytest.fixture(scope='''session''' ) def lowerCamelCase_ ( UpperCamelCase__ : List[str] ): '''simple docstring''' UpperCamelCase__ = tmp_path_factory.mktemp('''data_dir''' ) (data_dir / "subdir").mkdir() with open(data_dir / '''subdir''' / '''train.txt''', '''w''' ) as f: f.write('''foo\n''' * 10 ) with open(data_dir / '''subdir''' / '''test.txt''', '''w''' ) as f: f.write('''bar\n''' * 10 ) # hidden file with open(data_dir / '''subdir''' / '''.test.txt''', '''w''' ) as f: f.write('''bar\n''' * 10 ) # hidden directory (data_dir / ".subdir").mkdir() with open(data_dir / '''.subdir''' / '''train.txt''', '''w''' ) as f: f.write('''foo\n''' * 10 ) with open(data_dir / '''.subdir''' / '''test.txt''', '''w''' ) as f: f.write('''bar\n''' * 10 ) return data_dir

from __future__ import annotations lowercase = list[list[int]] # assigning initial values to the grid lowercase = [ [3, 0, 6, 5, 0, 8, 4, 0, 0], [5, 2, 0, 0, 0, 0, 0, 0, 0], [0, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] # a grid with no solution lowercase = [ [5, 0, 6, 5, 0, 8, 4, 0, 3], [5, 2, 0, 0, 0, 0, 0, 0, 2], [1, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] def lowerCamelCase_ ( UpperCamelCase__ : Matrix, UpperCamelCase__ : int, UpperCamelCase__ : int, UpperCamelCase__ : int ): '''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 lowerCamelCase_ ( UpperCamelCase__ : Matrix ): '''simple docstring''' for i in range(9 ): for j in range(9 ): if grid[i][j] == 0: return i, j return None def lowerCamelCase_ ( UpperCamelCase__ : Matrix ): '''simple docstring''' if location := find_empty_location(UpperCamelCase__ ): UpperCamelCase__ , UpperCamelCase__ = location else: # If the location is ``None``, then the grid is solved. return grid for digit in range(1, 10 ): if is_safe(UpperCamelCase__, UpperCamelCase__, UpperCamelCase__, UpperCamelCase__ ): UpperCamelCase__ = digit if sudoku(UpperCamelCase__ ) is not None: return grid UpperCamelCase__ = 0 return None def lowerCamelCase_ ( UpperCamelCase__ : Matrix ): '''simple docstring''' for row in grid: for cell in row: print(UpperCamelCase__, end=''' ''' ) print() if __name__ == "__main__": # make a copy of grid so that you can compare with the unmodified grid for example_grid in (initial_grid, no_solution): print("""\nExample grid:\n""" + """=""" * 2_0) print_solution(example_grid) print("""\nExample grid solution:""") lowercase = sudoku(example_grid) if solution is not None: print_solution(solution) else: print("""Cannot find a solution.""")

import torch from torch import nn from ...configuration_utils import ConfigMixin, register_to_config from ...models import ModelMixin class UpperCamelCase__ (lowerCAmelCase__ , lowerCAmelCase__ ): '''simple docstring''' @register_to_config def __init__( self , *, UpperCamelCase__ = 4 , UpperCamelCase__ = 768 , UpperCamelCase__ , UpperCamelCase__ , ) -> Union[str, Any]: super().__init__() lowerCamelCase : List[str] = nn.Parameter(torch.zeros(UpperCamelCase__ ) ) # parameters for additional clip time embeddings lowerCamelCase : Any = nn.Linear(UpperCamelCase__ , UpperCamelCase__ ) lowerCamelCase : Any = nn.Linear(UpperCamelCase__ , UpperCamelCase__ ) # parameters for encoder hidden states lowerCamelCase : Dict = clip_extra_context_tokens lowerCamelCase : Tuple = nn.Linear( UpperCamelCase__ , self.clip_extra_context_tokens * cross_attention_dim ) lowerCamelCase : str = nn.Linear(UpperCamelCase__ , UpperCamelCase__ ) lowerCamelCase : Dict = nn.LayerNorm(UpperCamelCase__ ) def _lowercase ( self , *, UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) -> Any: if do_classifier_free_guidance: # Add the classifier free guidance embeddings to the image embeddings lowerCamelCase : Union[str, Any] = image_embeddings.shape[0] lowerCamelCase : Optional[Any] = self.learned_classifier_free_guidance_embeddings.unsqueeze(0 ) lowerCamelCase : Optional[Any] = classifier_free_guidance_embeddings.expand( UpperCamelCase__ , -1 ) lowerCamelCase : Any = torch.cat([classifier_free_guidance_embeddings, image_embeddings] , dim=0 ) # The image embeddings batch size and the text embeddings batch size are equal assert image_embeddings.shape[0] == prompt_embeds.shape[0] lowerCamelCase : Union[str, Any] = prompt_embeds.shape[0] # "Specifically, we modify the architecture described in Nichol et al. (2021) by projecting and # adding CLIP embeddings to the existing timestep embedding, ... lowerCamelCase : str = self.embedding_proj(UpperCamelCase__ ) lowerCamelCase : str = self.clip_image_embeddings_project_to_time_embeddings(UpperCamelCase__ ) lowerCamelCase : Any = time_projected_image_embeddings + time_projected_prompt_embeds # ... and by projecting CLIP embeddings into four # extra tokens of context that are concatenated to the sequence of outputs from the GLIDE text encoder" lowerCamelCase : str = self.clip_extra_context_tokens_proj(UpperCamelCase__ ) lowerCamelCase : Any = clip_extra_context_tokens.reshape(UpperCamelCase__ , -1 , self.clip_extra_context_tokens ) lowerCamelCase : Optional[int] = clip_extra_context_tokens.permute(0 , 2 , 1 ) lowerCamelCase : Optional[Any] = self.encoder_hidden_states_proj(UpperCamelCase__ ) lowerCamelCase : List[str] = self.text_encoder_hidden_states_norm(UpperCamelCase__ ) lowerCamelCase : Optional[int] = torch.cat([clip_extra_context_tokens, text_encoder_hidden_states] , dim=1 ) return text_encoder_hidden_states, additive_clip_time_embeddings

import os from shutil import copyfile from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging lowerCAmelCase : Optional[Any] = logging.get_logger(__name__) lowerCAmelCase : Any = {'vocab_file': 'spiece.model'} lowerCAmelCase : Tuple = { 'vocab_file': { 'bert_for_seq_generation': ( 'https://huggingface.co/google/bert_for_seq_generation_L-24_bbc_encoder/resolve/main/spiece.model' ), } } lowerCAmelCase : Optional[int] = {'bert_for_seq_generation': 5_12} class _A ( __magic_name__): SCREAMING_SNAKE_CASE : Dict = VOCAB_FILES_NAMES SCREAMING_SNAKE_CASE : Optional[int] = PRETRAINED_VOCAB_FILES_MAP SCREAMING_SNAKE_CASE : List[str] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES SCREAMING_SNAKE_CASE : List[int] = [] SCREAMING_SNAKE_CASE : Dict = ['''input_ids''', '''attention_mask'''] def __init__( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE="<s>" , _SCREAMING_SNAKE_CASE="</s>" , _SCREAMING_SNAKE_CASE="<unk>" , _SCREAMING_SNAKE_CASE="<pad>" , _SCREAMING_SNAKE_CASE="<::::>" , _SCREAMING_SNAKE_CASE = None , **_SCREAMING_SNAKE_CASE , ): """simple docstring""" SCREAMING_SNAKE_CASE_ : Tuple = {} if sp_model_kwargs is None else sp_model_kwargs # Add extra_ids to the special token list super().__init__( bos_token=_SCREAMING_SNAKE_CASE , eos_token=_SCREAMING_SNAKE_CASE , unk_token=_SCREAMING_SNAKE_CASE , pad_token=_SCREAMING_SNAKE_CASE , sep_token=_SCREAMING_SNAKE_CASE , sp_model_kwargs=self.sp_model_kwargs , **_SCREAMING_SNAKE_CASE , ) SCREAMING_SNAKE_CASE_ : List[str] = vocab_file SCREAMING_SNAKE_CASE_ : Any = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(_SCREAMING_SNAKE_CASE ) @property def UpperCAmelCase ( self ): """simple docstring""" return self.sp_model.get_piece_size() def UpperCAmelCase ( self ): """simple docstring""" SCREAMING_SNAKE_CASE_ : List[Any] = {self.convert_ids_to_tokens(_SCREAMING_SNAKE_CASE ): i for i in range(self.vocab_size )} vocab.update(self.added_tokens_encoder ) return vocab def __getstate__( self ): """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[int] = self.__dict__.copy() SCREAMING_SNAKE_CASE_ : List[Any] = None return state def __setstate__( self , _SCREAMING_SNAKE_CASE ): """simple docstring""" SCREAMING_SNAKE_CASE_ : List[str] = d # for backward compatibility if not hasattr(self , 'sp_model_kwargs' ): SCREAMING_SNAKE_CASE_ : Dict = {} SCREAMING_SNAKE_CASE_ : str = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(self.vocab_file ) def UpperCAmelCase ( self , _SCREAMING_SNAKE_CASE ): """simple docstring""" return self.sp_model.encode(_SCREAMING_SNAKE_CASE , out_type=_SCREAMING_SNAKE_CASE ) def UpperCAmelCase ( self , _SCREAMING_SNAKE_CASE ): """simple docstring""" return self.sp_model.piece_to_id(_SCREAMING_SNAKE_CASE ) def UpperCAmelCase ( self , _SCREAMING_SNAKE_CASE ): """simple docstring""" SCREAMING_SNAKE_CASE_ : int = self.sp_model.IdToPiece(_SCREAMING_SNAKE_CASE ) return token def UpperCAmelCase ( self , _SCREAMING_SNAKE_CASE ): """simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[Any] = [] SCREAMING_SNAKE_CASE_ : Optional[int] = '' for token in tokens: # make sure that special tokens are not decoded using sentencepiece model if token in self.all_special_tokens: out_string += self.sp_model.decode(_SCREAMING_SNAKE_CASE ) + token SCREAMING_SNAKE_CASE_ : Optional[int] = [] else: current_sub_tokens.append(_SCREAMING_SNAKE_CASE ) out_string += self.sp_model.decode(_SCREAMING_SNAKE_CASE ) return out_string.strip() def UpperCAmelCase ( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE = None ): """simple docstring""" if not os.path.isdir(_SCREAMING_SNAKE_CASE ): logger.error(f"Vocabulary path ({save_directory}) should be a directory" ) return SCREAMING_SNAKE_CASE_ : Optional[Any] = os.path.join( _SCREAMING_SNAKE_CASE , (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file'] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(_SCREAMING_SNAKE_CASE ) and os.path.isfile(self.vocab_file ): copyfile(self.vocab_file , _SCREAMING_SNAKE_CASE ) elif not os.path.isfile(self.vocab_file ): with open(_SCREAMING_SNAKE_CASE , 'wb' ) as fi: SCREAMING_SNAKE_CASE_ : List[Any] = self.sp_model.serialized_model_proto() fi.write(_SCREAMING_SNAKE_CASE ) return (out_vocab_file,)

"""simple docstring""" # Copyright 2022 The HuggingFace Team and The OpenBMB Team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from typing import TYPE_CHECKING # rely on isort to merge the imports from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available lowerCAmelCase__ = { '''configuration_cpmant''': ['''CPMANT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''CpmAntConfig'''], '''tokenization_cpmant''': ['''CpmAntTokenizer'''], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowerCAmelCase__ = [ '''CPMANT_PRETRAINED_MODEL_ARCHIVE_LIST''', '''CpmAntForCausalLM''', '''CpmAntModel''', '''CpmAntPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_cpmant import CPMANT_PRETRAINED_CONFIG_ARCHIVE_MAP, CpmAntConfig from .tokenization_cpmant import CpmAntTokenizer try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_cpmant import ( CPMANT_PRETRAINED_MODEL_ARCHIVE_LIST, CpmAntForCausalLM, CpmAntModel, CpmAntPreTrainedModel, ) else: import sys lowerCAmelCase__ = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

"""simple docstring""" import pytest from datasets.parallel import ParallelBackendConfig, parallel_backend from datasets.utils.py_utils import map_nested from .utils import require_dill_gt_0_3_2, require_joblibspark, require_not_windows def a__ ( SCREAMING_SNAKE_CASE : str ): # picklable for multiprocessing '''simple docstring''' return i + 1 @require_dill_gt_0_3_2 @require_joblibspark @require_not_windows def a__ ( ): '''simple docstring''' with parallel_backend("spark" ): assert ParallelBackendConfig.backend_name == "spark" lowerCAmelCase : List[str] = [1, 2, 3] with pytest.raises(SCREAMING_SNAKE_CASE ): with parallel_backend("unsupported backend" ): map_nested(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , num_proc=2 ) with pytest.raises(SCREAMING_SNAKE_CASE ): with parallel_backend("unsupported backend" ): map_nested(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , num_proc=-1 ) @require_dill_gt_0_3_2 @require_joblibspark @require_not_windows @pytest.mark.parametrize("num_proc" , [2, -1] ) def a__ ( SCREAMING_SNAKE_CASE : Tuple ): '''simple docstring''' lowerCAmelCase : Tuple = [1, 2] lowerCAmelCase : int = {"a": 1, "b": 2} lowerCAmelCase : List[str] = {"a": [1, 2], "b": [3, 4]} lowerCAmelCase : Dict = {"a": {"1": 1}, "b": 2} lowerCAmelCase : Tuple = {"a": 1, "b": 2, "c": 3, "d": 4} lowerCAmelCase : Any = [2, 3] lowerCAmelCase : Any = {"a": 2, "b": 3} lowerCAmelCase : Optional[int] = {"a": [2, 3], "b": [4, 5]} lowerCAmelCase : Optional[int] = {"a": {"1": 2}, "b": 3} lowerCAmelCase : str = {"a": 2, "b": 3, "c": 4, "d": 5} with parallel_backend("spark" ): assert map_nested(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , num_proc=SCREAMING_SNAKE_CASE ) == expected_map_nested_sa assert map_nested(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , num_proc=SCREAMING_SNAKE_CASE ) == expected_map_nested_sa assert map_nested(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , num_proc=SCREAMING_SNAKE_CASE ) == expected_map_nested_sa assert map_nested(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , num_proc=SCREAMING_SNAKE_CASE ) == expected_map_nested_sa assert map_nested(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , num_proc=SCREAMING_SNAKE_CASE ) == expected_map_nested_sa

'''simple docstring''' import math from typing import Dict, Iterable, List, Optional, Tuple, Union import numpy as np from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict from ...image_transforms import normalize, rescale, resize, to_channel_dimension_format from ...image_utils import ( IMAGENET_STANDARD_MEAN, IMAGENET_STANDARD_STD, ChannelDimension, ImageInput, PILImageResampling, get_image_size, is_torch_available, is_torch_tensor, make_list_of_images, to_numpy_array, valid_images, ) from ...utils import TensorType, is_vision_available, logging if is_torch_available(): import torch if is_vision_available(): import PIL __SCREAMING_SNAKE_CASE : int = logging.get_logger(__name__) def UpperCamelCase_ ( _UpperCAmelCase : np.ndarray , _UpperCAmelCase : Union[int, Iterable[int]] , _UpperCAmelCase : bool , _UpperCAmelCase : int ) -> Tuple[int, int]: """simple docstring""" def constraint_to_multiple_of(_UpperCAmelCase : Tuple , _UpperCAmelCase : List[Any] , _UpperCAmelCase : Any=0 , _UpperCAmelCase : List[Any]=None ): _UpperCAmelCase : Tuple = round(val / multiple ) * multiple if max_val is not None and x > max_val: _UpperCAmelCase : Any = math.floor(val / multiple ) * multiple if x < min_val: _UpperCAmelCase : Optional[Any] = math.ceil(val / multiple ) * multiple return x _UpperCAmelCase : str = (output_size, output_size) if isinstance(_UpperCAmelCase , _UpperCAmelCase ) else output_size _UpperCAmelCase , _UpperCAmelCase : Dict = get_image_size(_UpperCAmelCase ) _UpperCAmelCase , _UpperCAmelCase : Dict = output_size # determine new height and width _UpperCAmelCase : List[str] = output_height / input_height _UpperCAmelCase : str = output_width / input_width if keep_aspect_ratio: # scale as little as possible if abs(1 - scale_width ) < abs(1 - scale_height ): # fit width _UpperCAmelCase : Any = scale_width else: # fit height _UpperCAmelCase : List[Any] = scale_height _UpperCAmelCase : Union[str, Any] = constraint_to_multiple_of(scale_height * input_height , multiple=_UpperCAmelCase ) _UpperCAmelCase : Optional[int] = constraint_to_multiple_of(scale_width * input_width , multiple=_UpperCAmelCase ) return (new_height, new_width) class lowerCamelCase_ (snake_case__ ): '''simple docstring''' __UpperCamelCase: str = ["pixel_values"] def __init__( self : List[str] , A : bool = True , A : Dict[str, int] = None , A : PILImageResampling = PILImageResampling.BILINEAR , A : bool = False , A : int = 1 , A : bool = True , A : Union[int, float] = 1 / 255 , A : bool = True , A : Optional[Union[float, List[float]]] = None , A : Optional[Union[float, List[float]]] = None , **A : Dict , ): super().__init__(**A ) _UpperCAmelCase : Optional[Any] = size if size is not None else {"height": 384, "width": 384} _UpperCAmelCase : List[Any] = get_size_dict(A ) _UpperCAmelCase : Optional[int] = do_resize _UpperCAmelCase : str = size _UpperCAmelCase : Any = keep_aspect_ratio _UpperCAmelCase : Any = ensure_multiple_of _UpperCAmelCase : Dict = resample _UpperCAmelCase : List[str] = do_rescale _UpperCAmelCase : List[Any] = rescale_factor _UpperCAmelCase : str = do_normalize _UpperCAmelCase : Tuple = image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN _UpperCAmelCase : Optional[Any] = image_std if image_std is not None else IMAGENET_STANDARD_STD def _A ( self : List[str] , A : np.ndarray , A : Dict[str, int] , A : bool = False , A : int = 1 , A : PILImageResampling = PILImageResampling.BICUBIC , A : Optional[Union[str, ChannelDimension]] = None , **A : int , ): _UpperCAmelCase : Optional[Any] = get_size_dict(A ) if "height" not in size or "width" not in size: raise ValueError(F"""The size dictionary must contain the keys 'height' and 'width'. Got {size.keys()}""" ) _UpperCAmelCase : Optional[Any] = get_resize_output_image_size( A , output_size=(size["height"], size["width"]) , keep_aspect_ratio=A , multiple=A , ) return resize(A , size=A , resample=A , data_format=A , **A ) def _A ( self : List[Any] , A : np.ndarray , A : Union[int, float] , A : Optional[Union[str, ChannelDimension]] = None , **A : Union[str, Any] , ): return rescale(A , scale=A , data_format=A , **A ) def _A ( self : List[Any] , A : np.ndarray , A : Union[float, List[float]] , A : Union[float, List[float]] , A : Optional[Union[str, ChannelDimension]] = None , **A : Any , ): return normalize(A , mean=A , std=A , data_format=A , **A ) def _A ( self : List[Any] , A : ImageInput , A : bool = None , A : int = None , A : bool = None , A : int = None , A : PILImageResampling = None , A : bool = None , A : float = None , A : bool = None , A : Optional[Union[float, List[float]]] = None , A : Optional[Union[float, List[float]]] = None , A : Optional[Union[str, TensorType]] = None , A : ChannelDimension = ChannelDimension.FIRST , **A : Any , ): _UpperCAmelCase : Union[str, Any] = do_resize if do_resize is not None else self.do_resize _UpperCAmelCase : List[Any] = size if size is not None else self.size _UpperCAmelCase : Optional[int] = get_size_dict(A ) _UpperCAmelCase : Optional[Any] = keep_aspect_ratio if keep_aspect_ratio is not None else self.keep_aspect_ratio _UpperCAmelCase : List[str] = ensure_multiple_of if ensure_multiple_of is not None else self.ensure_multiple_of _UpperCAmelCase : List[Any] = resample if resample is not None else self.resample _UpperCAmelCase : Tuple = do_rescale if do_rescale is not None else self.do_rescale _UpperCAmelCase : str = rescale_factor if rescale_factor is not None else self.rescale_factor _UpperCAmelCase : Any = do_normalize if do_normalize is not None else self.do_normalize _UpperCAmelCase : List[Any] = image_mean if image_mean is not None else self.image_mean _UpperCAmelCase : Any = image_std if image_std is not None else self.image_std _UpperCAmelCase : Optional[int] = make_list_of_images(A ) if not valid_images(A ): raise ValueError( "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, " "torch.Tensor, tf.Tensor or jax.ndarray." ) if do_resize and size is None or resample is None: raise ValueError("Size and resample must be specified if do_resize is True." ) if do_rescale and rescale_factor is None: raise ValueError("Rescale factor must be specified if do_rescale is True." ) if do_normalize and (image_mean is None or image_std is None): raise ValueError("Image mean and std must be specified if do_normalize is True." ) # All transformations expect numpy arrays. _UpperCAmelCase : Optional[Any] = [to_numpy_array(A ) for image in images] if do_resize: _UpperCAmelCase : Dict = [self.resize(image=A , size=A , resample=A ) for image in images] if do_rescale: _UpperCAmelCase : Union[str, Any] = [self.rescale(image=A , scale=A ) for image in images] if do_normalize: _UpperCAmelCase : Tuple = [self.normalize(image=A , mean=A , std=A ) for image in images] _UpperCAmelCase : Tuple = [to_channel_dimension_format(A , A ) for image in images] _UpperCAmelCase : Any = {"pixel_values": images} return BatchFeature(data=A , tensor_type=A ) def _A ( self : Optional[int] , A : List[str] , A : List[Tuple] = None ): _UpperCAmelCase : List[str] = 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 ): _UpperCAmelCase : Optional[int] = target_sizes.numpy() _UpperCAmelCase : Any = [] for idx in range(len(A ) ): _UpperCAmelCase : List[Any] = torch.nn.functional.interpolate( logits[idx].unsqueeze(dim=0 ) , size=target_sizes[idx] , mode="bilinear" , align_corners=A ) _UpperCAmelCase : Optional[Any] = resized_logits[0].argmax(dim=0 ) semantic_segmentation.append(A ) else: _UpperCAmelCase : Any = logits.argmax(dim=1 ) _UpperCAmelCase : Dict = [semantic_segmentation[i] for i in range(semantic_segmentation.shape[0] )] return semantic_segmentation

'''simple docstring''' from typing import Any def UpperCamelCase_ ( _UpperCAmelCase : list , _UpperCAmelCase : list , _UpperCAmelCase : dict , _UpperCAmelCase : dict , _UpperCAmelCase : dict , ) -> list: """simple docstring""" _validation( _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , ) # Creates data structures and fill initial step _UpperCAmelCase : dict = {} _UpperCAmelCase : dict = {} for state in states_space: _UpperCAmelCase : Union[str, Any] = observations_space[0] _UpperCAmelCase : Tuple = ( initial_probabilities[state] * emission_probabilities[state][observation] ) _UpperCAmelCase : List[str] = None # Fills the data structure with the probabilities of # different transitions and pointers to previous states for o in range(1 , len(_UpperCAmelCase ) ): _UpperCAmelCase : Optional[Any] = observations_space[o] _UpperCAmelCase : int = observations_space[o - 1] for state in states_space: # Calculates the argmax for probability function _UpperCAmelCase : str = "" _UpperCAmelCase : Tuple = -1 for k_state in states_space: _UpperCAmelCase : Any = ( probabilities[(k_state, prior_observation)] * transition_probabilities[k_state][state] * emission_probabilities[state][observation] ) if probability > max_probability: _UpperCAmelCase : Union[str, Any] = probability _UpperCAmelCase : str = k_state # Update probabilities and pointers dicts _UpperCAmelCase : Optional[int] = ( probabilities[(arg_max, prior_observation)] * transition_probabilities[arg_max][state] * emission_probabilities[state][observation] ) _UpperCAmelCase : Tuple = arg_max # The final observation _UpperCAmelCase : Optional[Any] = observations_space[len(_UpperCAmelCase ) - 1] # argmax for given final observation _UpperCAmelCase : List[str] = "" _UpperCAmelCase : Any = -1 for k_state in states_space: _UpperCAmelCase : Optional[int] = probabilities[(k_state, final_observation)] if probability > max_probability: _UpperCAmelCase : int = probability _UpperCAmelCase : Dict = k_state _UpperCAmelCase : Dict = arg_max # Process pointers backwards _UpperCAmelCase : List[Any] = last_state _UpperCAmelCase : str = [] for o in range(len(_UpperCAmelCase ) - 1 , -1 , -1 ): result.append(_UpperCAmelCase ) _UpperCAmelCase : List[Any] = pointers[previous, observations_space[o]] result.reverse() return result def UpperCamelCase_ ( _UpperCAmelCase : Any , _UpperCAmelCase : Any , _UpperCAmelCase : Any , _UpperCAmelCase : Any , _UpperCAmelCase : Any , ) -> None: """simple docstring""" _validate_not_empty( _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , ) _validate_lists(_UpperCAmelCase , _UpperCAmelCase ) _validate_dicts( _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) def UpperCamelCase_ ( _UpperCAmelCase : Any , _UpperCAmelCase : Any , _UpperCAmelCase : Any , _UpperCAmelCase : Any , _UpperCAmelCase : Any , ) -> None: """simple docstring""" if not all( [ observations_space, states_space, initial_probabilities, transition_probabilities, emission_probabilities, ] ): raise ValueError("There's an empty parameter" ) def UpperCamelCase_ ( _UpperCAmelCase : Any , _UpperCAmelCase : Any ) -> None: """simple docstring""" _validate_list(_UpperCAmelCase , "observations_space" ) _validate_list(_UpperCAmelCase , "states_space" ) def UpperCamelCase_ ( _UpperCAmelCase : Any , _UpperCAmelCase : str ) -> None: """simple docstring""" if not isinstance(_object , _UpperCAmelCase ): _UpperCAmelCase : Optional[int] = F"""{var_name} must be a list""" raise ValueError(_UpperCAmelCase ) else: for x in _object: if not isinstance(_UpperCAmelCase , _UpperCAmelCase ): _UpperCAmelCase : Optional[int] = F"""{var_name} must be a list of strings""" raise ValueError(_UpperCAmelCase ) def UpperCamelCase_ ( _UpperCAmelCase : Any , _UpperCAmelCase : Any , _UpperCAmelCase : Any , ) -> None: """simple docstring""" _validate_dict(_UpperCAmelCase , "initial_probabilities" , _UpperCAmelCase ) _validate_nested_dict(_UpperCAmelCase , "transition_probabilities" ) _validate_nested_dict(_UpperCAmelCase , "emission_probabilities" ) def UpperCamelCase_ ( _UpperCAmelCase : Any , _UpperCAmelCase : str ) -> None: """simple docstring""" _validate_dict(_object , _UpperCAmelCase , _UpperCAmelCase ) for x in _object.values(): _validate_dict(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) def UpperCamelCase_ ( _UpperCAmelCase : Any , _UpperCAmelCase : str , _UpperCAmelCase : type , _UpperCAmelCase : bool = False ) -> None: """simple docstring""" if not isinstance(_object , _UpperCAmelCase ): _UpperCAmelCase : Any = F"""{var_name} must be a dict""" raise ValueError(_UpperCAmelCase ) if not all(isinstance(_UpperCAmelCase , _UpperCAmelCase ) for x in _object ): _UpperCAmelCase : Tuple = F"""{var_name} all keys must be strings""" raise ValueError(_UpperCAmelCase ) if not all(isinstance(_UpperCAmelCase , _UpperCAmelCase ) for x in _object.values() ): _UpperCAmelCase : List[str] = "nested dictionary " if nested else "" _UpperCAmelCase : List[str] = F"""{var_name} {nested_text}all values must be {value_type.__name__}""" raise ValueError(_UpperCAmelCase ) if __name__ == "__main__": from doctest import testmod testmod()

def __lowerCamelCase ( lowerCamelCase__ : int = 100 ): '''simple docstring''' lowerCamelCase = n * (n + 1) * (2 * n + 1) / 6 lowerCamelCase = (n * (n + 1) / 2) ** 2 return int(square_of_sum - sum_of_squares ) if __name__ == "__main__": print(f"""{solution() = }""")

import logging import os import sys from dataclasses import dataclass, field from itertools import chain from typing import Optional, Union import datasets import numpy as np import torch from datasets import load_dataset import transformers from transformers import ( AutoConfig, AutoModelForMultipleChoice, AutoTokenizer, HfArgumentParser, Trainer, TrainingArguments, default_data_collator, set_seed, ) from transformers.tokenization_utils_base import PreTrainedTokenizerBase from transformers.trainer_utils import get_last_checkpoint from transformers.utils import PaddingStrategy, check_min_version, send_example_telemetry # Will error if the minimal version of Transformers is not installed. Remove at your own risks. check_min_version("4.31.0") UpperCAmelCase : Optional[Any] = logging.getLogger(__name__) @dataclass class __lowercase : """simple docstring""" UpperCamelCase : str = field( metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"} ) UpperCamelCase : Optional[str] = field( default=a_ , metadata={"help": "Pretrained config name or path if not the same as model_name"} ) UpperCamelCase : Optional[str] = field( default=a_ , metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"} ) UpperCamelCase : Optional[str] = field( default=a_ , metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"} , ) UpperCamelCase : bool = field( default=a_ , metadata={"help": "Whether to use one of the fast tokenizer (backed by the tokenizers library) or not."} , ) UpperCamelCase : str = field( default="main" , metadata={"help": "The specific model version to use (can be a branch name, tag name or commit id)."} , ) UpperCamelCase : bool = field( default=a_ , metadata={ "help": ( "Will use the token generated when running `huggingface-cli login` (necessary to use this script " "with private models)." ) } , ) @dataclass class __lowercase : """simple docstring""" UpperCamelCase : Optional[str] = field(default=a_ , metadata={"help": "The input training data file (a text file)."} ) UpperCamelCase : Optional[str] = field( default=a_ , metadata={"help": "An optional input evaluation data file to evaluate the perplexity on (a text file)."} , ) UpperCamelCase : bool = field( default=a_ , metadata={"help": "Overwrite the cached training and evaluation sets"} ) UpperCamelCase : Optional[int] = field( default=a_ , metadata={"help": "The number of processes to use for the preprocessing."} , ) UpperCamelCase : Optional[int] = field( default=a_ , metadata={ "help": ( "The maximum total input sequence length after tokenization. If passed, sequences longer " "than this will be truncated, sequences shorter will be padded." ) } , ) UpperCamelCase : bool = field( default=a_ , metadata={ "help": ( "Whether to pad all samples to the maximum sentence length. " "If False, will pad the samples dynamically when batching to the maximum length in the batch. More " "efficient on GPU but very bad for TPU." ) } , ) UpperCamelCase : Optional[int] = field( default=a_ , metadata={ "help": ( "For debugging purposes or quicker training, truncate the number of training examples to this " "value if set." ) } , ) UpperCamelCase : Optional[int] = field( default=a_ , metadata={ "help": ( "For debugging purposes or quicker training, truncate the number of evaluation examples to this " "value if set." ) } , ) def __A ( self ) -> Any: '''simple docstring''' if self.train_file is not None: lowerCamelCase = self.train_file.split(""".""" )[-1] assert extension in ["csv", "json"], "`train_file` should be a csv or a json file." if self.validation_file is not None: lowerCamelCase = self.validation_file.split(""".""" )[-1] assert extension in ["csv", "json"], "`validation_file` should be a csv or a json file." @dataclass class __lowercase : """simple docstring""" UpperCamelCase : PreTrainedTokenizerBase UpperCamelCase : Union[bool, str, PaddingStrategy] = True UpperCamelCase : Optional[int] = None UpperCamelCase : Optional[int] = None def __call__( self , A ) -> Dict: '''simple docstring''' lowerCamelCase = """label""" if """label""" in features[0].keys() else """labels""" lowerCamelCase = [feature.pop(A ) for feature in features] lowerCamelCase = len(A ) lowerCamelCase = len(features[0]["""input_ids"""] ) lowerCamelCase = [ [{k: v[i] for k, v in feature.items()} for i in range(A )] for feature in features ] lowerCamelCase = list(chain(*A ) ) lowerCamelCase = self.tokenizer.pad( A , padding=self.padding , max_length=self.max_length , pad_to_multiple_of=self.pad_to_multiple_of , return_tensors="""pt""" , ) # Un-flatten lowerCamelCase = {k: v.view(A , A , -1 ) for k, v in batch.items()} # Add back labels lowerCamelCase = torch.tensor(A , dtype=torch.intaa ) return batch def __lowerCamelCase ( ): '''simple docstring''' lowerCamelCase = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments) ) if len(sys.argv ) == 2 and sys.argv[1].endswith(""".json""" ): # If we pass only one argument to the script and it's the path to a json file, # let's parse it to get our arguments. lowerCamelCase , lowerCamelCase , lowerCamelCase = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1] ) ) else: lowerCamelCase , lowerCamelCase , lowerCamelCase = parser.parse_args_into_dataclasses() # Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The # information sent is the one passed as arguments along with your Python/PyTorch versions. send_example_telemetry("""run_swag""" , lowerCamelCase__ , lowerCamelCase__ ) # Setup logging logging.basicConfig( format="""%(asctime)s - %(levelname)s - %(name)s - %(message)s""" , datefmt="""%m/%d/%Y %H:%M:%S""" , handlers=[logging.StreamHandler(sys.stdout )] , ) if training_args.should_log: # The default of training_args.log_level is passive, so we set log level at info here to have that default. transformers.utils.logging.set_verbosity_info() lowerCamelCase = training_args.get_process_log_level() logger.setLevel(lowerCamelCase__ ) datasets.utils.logging.set_verbosity(lowerCamelCase__ ) transformers.utils.logging.set_verbosity(lowerCamelCase__ ) transformers.utils.logging.enable_default_handler() transformers.utils.logging.enable_explicit_format() # Log on each process the small summary: logger.warning( f'Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}' + f'distributed training: {bool(training_args.local_rank != -1 )}, 16-bits training: {training_args.fpaa}' ) logger.info(f'Training/evaluation parameters {training_args}' ) # Detecting last checkpoint. lowerCamelCase = None if os.path.isdir(training_args.output_dir ) and training_args.do_train and not training_args.overwrite_output_dir: lowerCamelCase = get_last_checkpoint(training_args.output_dir ) if last_checkpoint is None and len(os.listdir(training_args.output_dir ) ) > 0: raise ValueError( f'Output directory ({training_args.output_dir}) already exists and is not empty. ' """Use --overwrite_output_dir to overcome.""" ) elif last_checkpoint is not None and training_args.resume_from_checkpoint is None: logger.info( f'Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change ' """the `--output_dir` or add `--overwrite_output_dir` to train from scratch.""" ) # Set seed before initializing model. set_seed(training_args.seed ) # Get the datasets: you can either provide your own CSV/JSON/TXT training and evaluation files (see below) # or just provide the name of one of the public datasets available on the hub at https://huggingface.co/datasets/ # (the dataset will be downloaded automatically from the datasets Hub). # For CSV/JSON files, this script will use the column called 'text' or the first column if no column called # 'text' is found. You can easily tweak this behavior (see below). # In distributed training, the load_dataset function guarantee that only one local process can concurrently # download the dataset. if data_args.train_file is not None or data_args.validation_file is not None: lowerCamelCase = {} if data_args.train_file is not None: lowerCamelCase = data_args.train_file if data_args.validation_file is not None: lowerCamelCase = data_args.validation_file lowerCamelCase = data_args.train_file.split(""".""" )[-1] lowerCamelCase = load_dataset( lowerCamelCase__ , data_files=lowerCamelCase__ , cache_dir=model_args.cache_dir , use_auth_token=True if model_args.use_auth_token else None , ) else: # Downloading and loading the swag dataset from the hub. lowerCamelCase = load_dataset( """swag""" , """regular""" , cache_dir=model_args.cache_dir , use_auth_token=True if model_args.use_auth_token else None , ) # See more about loading any type of standard or custom dataset (from files, python dict, pandas DataFrame, etc) at # https://huggingface.co/docs/datasets/loading_datasets.html. # Load pretrained model and tokenizer # Distributed training: # The .from_pretrained methods guarantee that only one local process can concurrently # download model & vocab. lowerCamelCase = AutoConfig.from_pretrained( model_args.config_name if model_args.config_name else model_args.model_name_or_path , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , ) lowerCamelCase = 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 , use_fast=model_args.use_fast_tokenizer , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , ) lowerCamelCase = AutoModelForMultipleChoice.from_pretrained( model_args.model_name_or_path , from_tf=bool(""".ckpt""" in model_args.model_name_or_path ) , config=lowerCamelCase__ , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , ) # When using your own dataset or a different dataset from swag, you will probably need to change this. lowerCamelCase = [f'ending{i}' for i in range(4 )] lowerCamelCase = """sent1""" lowerCamelCase = """sent2""" if data_args.max_seq_length is None: lowerCamelCase = tokenizer.model_max_length if max_seq_length > 1024: logger.warning( """The chosen tokenizer supports a `model_max_length` that is longer than the default `block_size` value""" """ of 1024. If you would like to use a longer `block_size` up to `tokenizer.model_max_length` you can""" """ override this default with `--block_size xxx`.""" ) lowerCamelCase = 1024 else: if data_args.max_seq_length > tokenizer.model_max_length: logger.warning( f'The max_seq_length passed ({data_args.max_seq_length}) is larger than the maximum length for the' f'model ({tokenizer.model_max_length}). Using max_seq_length={tokenizer.model_max_length}.' ) lowerCamelCase = min(data_args.max_seq_length , tokenizer.model_max_length ) # Preprocessing the datasets. def preprocess_function(lowerCamelCase__ : int ): lowerCamelCase = [[context] * 4 for context in examples[context_name]] lowerCamelCase = examples[question_header_name] lowerCamelCase = [ [f'{header} {examples[end][i]}' for end in ending_names] for i, header in enumerate(lowerCamelCase__ ) ] # Flatten out lowerCamelCase = list(chain(*lowerCamelCase__ ) ) lowerCamelCase = list(chain(*lowerCamelCase__ ) ) # Tokenize lowerCamelCase = tokenizer( lowerCamelCase__ , lowerCamelCase__ , truncation=lowerCamelCase__ , max_length=lowerCamelCase__ , padding="""max_length""" if data_args.pad_to_max_length else False , ) # Un-flatten return {k: [v[i : i + 4] for i in range(0 , len(lowerCamelCase__ ) , 4 )] for k, v in tokenized_examples.items()} if training_args.do_train: if "train" not in raw_datasets: raise ValueError("""--do_train requires a train dataset""" ) lowerCamelCase = raw_datasets["""train"""] if data_args.max_train_samples is not None: lowerCamelCase = min(len(lowerCamelCase__ ) , data_args.max_train_samples ) lowerCamelCase = train_dataset.select(range(lowerCamelCase__ ) ) with training_args.main_process_first(desc="""train dataset map pre-processing""" ): lowerCamelCase = train_dataset.map( lowerCamelCase__ , batched=lowerCamelCase__ , num_proc=data_args.preprocessing_num_workers , load_from_cache_file=not data_args.overwrite_cache , ) if training_args.do_eval: if "validation" not in raw_datasets: raise ValueError("""--do_eval requires a validation dataset""" ) lowerCamelCase = raw_datasets["""validation"""] if data_args.max_eval_samples is not None: lowerCamelCase = min(len(lowerCamelCase__ ) , data_args.max_eval_samples ) lowerCamelCase = eval_dataset.select(range(lowerCamelCase__ ) ) with training_args.main_process_first(desc="""validation dataset map pre-processing""" ): lowerCamelCase = eval_dataset.map( lowerCamelCase__ , batched=lowerCamelCase__ , num_proc=data_args.preprocessing_num_workers , load_from_cache_file=not data_args.overwrite_cache , ) # Data collator lowerCamelCase = ( default_data_collator if data_args.pad_to_max_length else DataCollatorForMultipleChoice(tokenizer=lowerCamelCase__ , pad_to_multiple_of=8 if training_args.fpaa else None ) ) # Metric def compute_metrics(lowerCamelCase__ : Optional[int] ): lowerCamelCase , lowerCamelCase = eval_predictions lowerCamelCase = np.argmax(lowerCamelCase__ , axis=1 ) return {"accuracy": (preds == label_ids).astype(np.floataa ).mean().item()} # Initialize our Trainer lowerCamelCase = Trainer( model=lowerCamelCase__ , args=lowerCamelCase__ , train_dataset=train_dataset if training_args.do_train else None , eval_dataset=eval_dataset if training_args.do_eval else None , tokenizer=lowerCamelCase__ , data_collator=lowerCamelCase__ , compute_metrics=lowerCamelCase__ , ) # Training if training_args.do_train: lowerCamelCase = None if training_args.resume_from_checkpoint is not None: lowerCamelCase = training_args.resume_from_checkpoint elif last_checkpoint is not None: lowerCamelCase = last_checkpoint lowerCamelCase = trainer.train(resume_from_checkpoint=lowerCamelCase__ ) trainer.save_model() # Saves the tokenizer too for easy upload lowerCamelCase = train_result.metrics lowerCamelCase = ( data_args.max_train_samples if data_args.max_train_samples is not None else len(lowerCamelCase__ ) ) lowerCamelCase = min(lowerCamelCase__ , len(lowerCamelCase__ ) ) trainer.log_metrics("""train""" , lowerCamelCase__ ) trainer.save_metrics("""train""" , lowerCamelCase__ ) trainer.save_state() # Evaluation if training_args.do_eval: logger.info("""*** Evaluate ***""" ) lowerCamelCase = trainer.evaluate() lowerCamelCase = data_args.max_eval_samples if data_args.max_eval_samples is not None else len(lowerCamelCase__ ) lowerCamelCase = min(lowerCamelCase__ , len(lowerCamelCase__ ) ) trainer.log_metrics("""eval""" , lowerCamelCase__ ) trainer.save_metrics("""eval""" , lowerCamelCase__ ) lowerCamelCase = { """finetuned_from""": model_args.model_name_or_path, """tasks""": """multiple-choice""", """dataset_tags""": """swag""", """dataset_args""": """regular""", """dataset""": """SWAG""", """language""": """en""", } if training_args.push_to_hub: trainer.push_to_hub(**lowerCamelCase__ ) else: trainer.create_model_card(**lowerCamelCase__ ) def __lowerCamelCase ( lowerCamelCase__ : List[Any] ): '''simple docstring''' main() if __name__ == "__main__": main()

"""simple docstring""" import unittest import numpy as np from transformers import DistilBertConfig, is_flax_available from transformers.testing_utils import require_flax, slow from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask if is_flax_available(): import jax.numpy as jnp from transformers.models.distilbert.modeling_flax_distilbert import ( FlaxDistilBertForMaskedLM, FlaxDistilBertForMultipleChoice, FlaxDistilBertForQuestionAnswering, FlaxDistilBertForSequenceClassification, FlaxDistilBertForTokenClassification, FlaxDistilBertModel, ) class A_ (unittest.TestCase ): '''simple docstring''' def __init__( self , lowercase_ , lowercase_=13 , lowercase_=7 , lowercase_=True , lowercase_=True , lowercase_=True , lowercase_=True , lowercase_=99 , lowercase_=32 , lowercase_=5 , lowercase_=4 , lowercase_=37 , lowercase_="gelu" , lowercase_=0.1 , lowercase_=0.1 , lowercase_=512 , lowercase_=16 , lowercase_=2 , lowercase_=0.02 , lowercase_=4 , ): """simple docstring""" UpperCAmelCase_ : str = parent UpperCAmelCase_ : Dict = batch_size UpperCAmelCase_ : int = seq_length UpperCAmelCase_ : Any = is_training UpperCAmelCase_ : int = use_attention_mask UpperCAmelCase_ : List[str] = use_token_type_ids UpperCAmelCase_ : Union[str, Any] = use_labels UpperCAmelCase_ : Optional[Any] = vocab_size UpperCAmelCase_ : str = hidden_size UpperCAmelCase_ : Dict = num_hidden_layers UpperCAmelCase_ : Dict = num_attention_heads UpperCAmelCase_ : Union[str, Any] = intermediate_size UpperCAmelCase_ : Dict = hidden_act UpperCAmelCase_ : Tuple = hidden_dropout_prob UpperCAmelCase_ : int = attention_probs_dropout_prob UpperCAmelCase_ : Tuple = max_position_embeddings UpperCAmelCase_ : List[str] = type_vocab_size UpperCAmelCase_ : str = type_sequence_label_size UpperCAmelCase_ : List[str] = initializer_range UpperCAmelCase_ : Any = num_choices def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ : Optional[int] = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) UpperCAmelCase_ : List[Any] = None if self.use_attention_mask: UpperCAmelCase_ : List[str] = random_attention_mask([self.batch_size, self.seq_length] ) UpperCAmelCase_ : int = DistilBertConfig( vocab_size=self.vocab_size , dim=self.hidden_size , n_layers=self.num_hidden_layers , n_heads=self.num_attention_heads , hidden_dim=self.intermediate_size , hidden_act=self.hidden_act , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , initializer_range=self.initializer_range , tie_weights_=lowercase_ , ) return config, input_ids, attention_mask def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ : List[str] = self.prepare_config_and_inputs() UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : Any = config_and_inputs UpperCAmelCase_ : Dict = {"input_ids": input_ids, "attention_mask": attention_mask} return config, inputs_dict @require_flax class A_ (lowercase__ ,unittest.TestCase ): '''simple docstring''' SCREAMING_SNAKE_CASE__ : Dict = ( ( FlaxDistilBertModel, FlaxDistilBertForMaskedLM, FlaxDistilBertForMultipleChoice, FlaxDistilBertForQuestionAnswering, FlaxDistilBertForSequenceClassification, FlaxDistilBertForTokenClassification, FlaxDistilBertForQuestionAnswering, ) if is_flax_available() else () ) def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ : List[Any] = FlaxDistilBertModelTester(self ) @slow def UpperCamelCase__ ( self ): """simple docstring""" for model_class_name in self.all_model_classes: UpperCAmelCase_ : int = model_class_name.from_pretrained("distilbert-base-uncased" ) UpperCAmelCase_ : List[Any] = model(np.ones((1, 1) ) ) self.assertIsNotNone(lowercase_ ) @require_flax class A_ (unittest.TestCase ): '''simple docstring''' @slow def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ : Tuple = FlaxDistilBertModel.from_pretrained("distilbert-base-uncased" ) UpperCAmelCase_ : Optional[Any] = np.array([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]] ) UpperCAmelCase_ : Dict = np.array([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] ) UpperCAmelCase_ : Union[str, Any] = model(lowercase_ , attention_mask=lowercase_ )[0] UpperCAmelCase_ : Dict = (1, 11, 768) self.assertEqual(output.shape , lowercase_ ) UpperCAmelCase_ : int = np.array([[[-0.16_39, 0.32_99, 0.16_48], [-0.17_46, 0.32_89, 0.17_10], [-0.18_84, 0.33_57, 0.18_10]]] ) self.assertTrue(jnp.allclose(output[:, 1:4, 1:4] , lowercase_ , atol=1E-4 ) )

"""simple docstring""" import inspect import unittest import warnings from transformers import DeiTConfig from transformers.models.auto import get_values from transformers.testing_utils import ( require_accelerate, require_torch, require_torch_gpu, require_vision, slow, torch_device, ) from transformers.utils import cached_property, is_torch_available, is_vision_available from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from torch import nn from transformers import ( MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING, MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING, MODEL_MAPPING, DeiTForImageClassification, DeiTForImageClassificationWithTeacher, DeiTForMaskedImageModeling, DeiTModel, ) from transformers.models.deit.modeling_deit import DEIT_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import DeiTImageProcessor class A_ : '''simple docstring''' def __init__( self , lowercase_ , lowercase_=13 , lowercase_=30 , lowercase_=2 , lowercase_=3 , lowercase_=True , lowercase_=True , lowercase_=32 , lowercase_=5 , lowercase_=4 , lowercase_=37 , lowercase_="gelu" , lowercase_=0.1 , lowercase_=0.1 , lowercase_=10 , lowercase_=0.02 , lowercase_=3 , lowercase_=None , lowercase_=2 , ): """simple docstring""" UpperCAmelCase_ : List[str] = parent UpperCAmelCase_ : int = batch_size UpperCAmelCase_ : int = image_size UpperCAmelCase_ : List[Any] = patch_size UpperCAmelCase_ : Any = num_channels UpperCAmelCase_ : Optional[int] = is_training UpperCAmelCase_ : Union[str, Any] = use_labels UpperCAmelCase_ : Union[str, Any] = hidden_size UpperCAmelCase_ : str = num_hidden_layers UpperCAmelCase_ : List[str] = num_attention_heads UpperCAmelCase_ : str = intermediate_size UpperCAmelCase_ : str = hidden_act UpperCAmelCase_ : List[Any] = hidden_dropout_prob UpperCAmelCase_ : Union[str, Any] = attention_probs_dropout_prob UpperCAmelCase_ : str = type_sequence_label_size UpperCAmelCase_ : str = initializer_range UpperCAmelCase_ : Union[str, Any] = scope UpperCAmelCase_ : str = encoder_stride # in DeiT, the seq length equals the number of patches + 2 (we add 2 for the [CLS] and distilation tokens) UpperCAmelCase_ : int = (image_size // patch_size) ** 2 UpperCAmelCase_ : Optional[Any] = num_patches + 2 def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ : Any = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) UpperCAmelCase_ : Tuple = None if self.use_labels: UpperCAmelCase_ : Any = ids_tensor([self.batch_size] , self.type_sequence_label_size ) UpperCAmelCase_ : Union[str, Any] = self.get_config() return config, pixel_values, labels def UpperCamelCase__ ( self ): """simple docstring""" return DeiTConfig( image_size=self.image_size , patch_size=self.patch_size , num_channels=self.num_channels , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , is_decoder=lowercase_ , initializer_range=self.initializer_range , encoder_stride=self.encoder_stride , ) def UpperCamelCase__ ( self , lowercase_ , lowercase_ , lowercase_ ): """simple docstring""" UpperCAmelCase_ : Optional[int] = DeiTModel(config=lowercase_ ) model.to(lowercase_ ) model.eval() UpperCAmelCase_ : List[Any] = model(lowercase_ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def UpperCamelCase__ ( self , lowercase_ , lowercase_ , lowercase_ ): """simple docstring""" UpperCAmelCase_ : Optional[int] = DeiTForMaskedImageModeling(config=lowercase_ ) model.to(lowercase_ ) model.eval() UpperCAmelCase_ : List[Any] = model(lowercase_ ) self.parent.assertEqual( result.reconstruction.shape , (self.batch_size, self.num_channels, self.image_size, self.image_size) ) # test greyscale images UpperCAmelCase_ : List[str] = 1 UpperCAmelCase_ : Optional[Any] = DeiTForMaskedImageModeling(lowercase_ ) model.to(lowercase_ ) model.eval() UpperCAmelCase_ : Dict = floats_tensor([self.batch_size, 1, self.image_size, self.image_size] ) UpperCAmelCase_ : Optional[int] = model(lowercase_ ) self.parent.assertEqual(result.reconstruction.shape , (self.batch_size, 1, self.image_size, self.image_size) ) def UpperCamelCase__ ( self , lowercase_ , lowercase_ , lowercase_ ): """simple docstring""" UpperCAmelCase_ : Tuple = self.type_sequence_label_size UpperCAmelCase_ : Union[str, Any] = DeiTForImageClassification(lowercase_ ) model.to(lowercase_ ) model.eval() UpperCAmelCase_ : List[str] = model(lowercase_ , labels=lowercase_ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.type_sequence_label_size) ) # test greyscale images UpperCAmelCase_ : Union[str, Any] = 1 UpperCAmelCase_ : Optional[int] = DeiTForImageClassification(lowercase_ ) model.to(lowercase_ ) model.eval() UpperCAmelCase_ : Dict = floats_tensor([self.batch_size, 1, self.image_size, self.image_size] ) UpperCAmelCase_ : List[Any] = model(lowercase_ , labels=lowercase_ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.type_sequence_label_size) ) def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ : List[str] = self.prepare_config_and_inputs() ( ( UpperCAmelCase_ ) , ( UpperCAmelCase_ ) , ( UpperCAmelCase_ ) , ) : Dict = config_and_inputs UpperCAmelCase_ : Optional[int] = {"pixel_values": pixel_values} return config, inputs_dict @require_torch class A_ (lowercase__ ,lowercase__ ,unittest.TestCase ): '''simple docstring''' SCREAMING_SNAKE_CASE__ : Any = ( ( DeiTModel, DeiTForImageClassification, DeiTForImageClassificationWithTeacher, DeiTForMaskedImageModeling, ) if is_torch_available() else () ) SCREAMING_SNAKE_CASE__ : Tuple = ( { """feature-extraction""": DeiTModel, """image-classification""": (DeiTForImageClassification, DeiTForImageClassificationWithTeacher), } if is_torch_available() else {} ) SCREAMING_SNAKE_CASE__ : List[Any] = False SCREAMING_SNAKE_CASE__ : Optional[Any] = False SCREAMING_SNAKE_CASE__ : List[str] = False def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ : Any = DeiTModelTester(self ) UpperCAmelCase_ : Optional[int] = ConfigTester(self , config_class=lowercase_ , has_text_modality=lowercase_ , hidden_size=37 ) def UpperCamelCase__ ( self ): """simple docstring""" self.config_tester.run_common_tests() @unittest.skip(reason="DeiT does not use inputs_embeds" ) def UpperCamelCase__ ( self ): """simple docstring""" pass def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ , UpperCAmelCase_ : Any = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCAmelCase_ : List[Any] = model_class(lowercase_ ) self.assertIsInstance(model.get_input_embeddings() , (nn.Module) ) UpperCAmelCase_ : Any = model.get_output_embeddings() self.assertTrue(x is None or isinstance(lowercase_ , nn.Linear ) ) def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ , UpperCAmelCase_ : Dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCAmelCase_ : Dict = model_class(lowercase_ ) UpperCAmelCase_ : Optional[Any] = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic UpperCAmelCase_ : str = [*signature.parameters.keys()] UpperCAmelCase_ : Optional[int] = ["pixel_values"] self.assertListEqual(arg_names[:1] , lowercase_ ) def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*lowercase_ ) def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ : Dict = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_image_modeling(*lowercase_ ) def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ : Optional[int] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*lowercase_ ) def UpperCamelCase__ ( self , lowercase_ , lowercase_ , lowercase_=False ): """simple docstring""" UpperCAmelCase_ : Tuple = super()._prepare_for_class(lowercase_ , lowercase_ , return_labels=lowercase_ ) if return_labels: if model_class.__name__ == "DeiTForImageClassificationWithTeacher": del inputs_dict["labels"] return inputs_dict def UpperCamelCase__ ( self ): """simple docstring""" if not self.model_tester.is_training: return UpperCAmelCase_ , UpperCAmelCase_ : Union[str, Any] = self.model_tester.prepare_config_and_inputs_for_common() UpperCAmelCase_ : Union[str, Any] = True for model_class in self.all_model_classes: # DeiTForImageClassificationWithTeacher supports inference-only if ( model_class in get_values(lowercase_ ) or model_class.__name__ == "DeiTForImageClassificationWithTeacher" ): continue UpperCAmelCase_ : Optional[int] = model_class(lowercase_ ) model.to(lowercase_ ) model.train() UpperCAmelCase_ : List[Any] = self._prepare_for_class(lowercase_ , lowercase_ , return_labels=lowercase_ ) UpperCAmelCase_ : Dict = model(**lowercase_ ).loss loss.backward() def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ , UpperCAmelCase_ : int = self.model_tester.prepare_config_and_inputs_for_common() if not self.model_tester.is_training: return UpperCAmelCase_ : Dict = False UpperCAmelCase_ : Optional[int] = True for model_class in self.all_model_classes: if model_class in get_values(lowercase_ ) or not model_class.supports_gradient_checkpointing: continue # DeiTForImageClassificationWithTeacher supports inference-only if model_class.__name__ == "DeiTForImageClassificationWithTeacher": continue UpperCAmelCase_ : List[str] = model_class(lowercase_ ) model.gradient_checkpointing_enable() model.to(lowercase_ ) model.train() UpperCAmelCase_ : Optional[int] = self._prepare_for_class(lowercase_ , lowercase_ , return_labels=lowercase_ ) UpperCAmelCase_ : Any = model(**lowercase_ ).loss loss.backward() def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ , UpperCAmelCase_ : Tuple = self.model_tester.prepare_config_and_inputs_for_common() UpperCAmelCase_ : Dict = [ {"title": "multi_label_classification", "num_labels": 2, "dtype": torch.float}, {"title": "single_label_classification", "num_labels": 1, "dtype": torch.long}, {"title": "regression", "num_labels": 1, "dtype": torch.float}, ] for model_class in self.all_model_classes: if ( model_class not in [ *get_values(lowercase_ ), *get_values(lowercase_ ), ] or model_class.__name__ == "DeiTForImageClassificationWithTeacher" ): continue for problem_type in problem_types: with self.subTest(msg=F"""Testing {model_class} with {problem_type["title"]}""" ): UpperCAmelCase_ : str = problem_type["title"] UpperCAmelCase_ : List[Any] = problem_type["num_labels"] UpperCAmelCase_ : Union[str, Any] = model_class(lowercase_ ) model.to(lowercase_ ) model.train() UpperCAmelCase_ : int = self._prepare_for_class(lowercase_ , lowercase_ , return_labels=lowercase_ ) if problem_type["num_labels"] > 1: UpperCAmelCase_ : List[Any] = inputs["labels"].unsqueeze(1 ).repeat(1 , problem_type["num_labels"] ) UpperCAmelCase_ : Tuple = inputs["labels"].to(problem_type["dtype"] ) # This tests that we do not trigger the warning form PyTorch "Using a target size that is different # to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure # they have the same size." which is a symptom something in wrong for the regression problem. # See https://github.com/huggingface/transformers/issues/11780 with warnings.catch_warnings(record=lowercase_ ) as warning_list: UpperCAmelCase_ : List[str] = model(**lowercase_ ).loss for w in warning_list: if "Using a target size that is different to the input size" in str(w.message ): raise ValueError( F"""Something is going wrong in the regression problem: intercepted {w.message}""" ) loss.backward() @slow def UpperCamelCase__ ( self ): """simple docstring""" for model_name in DEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: UpperCAmelCase_ : Union[str, Any] = DeiTModel.from_pretrained(lowercase_ ) self.assertIsNotNone(lowercase_ ) def __a ( ): UpperCAmelCase_ : Any = Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png" ) return image @require_torch @require_vision class A_ (unittest.TestCase ): '''simple docstring''' @cached_property def UpperCamelCase__ ( self ): """simple docstring""" return ( DeiTImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224" ) if is_vision_available() else None ) @slow def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ : Tuple = DeiTForImageClassificationWithTeacher.from_pretrained("facebook/deit-base-distilled-patch16-224" ).to( lowercase_ ) UpperCAmelCase_ : List[str] = self.default_image_processor UpperCAmelCase_ : List[str] = prepare_img() UpperCAmelCase_ : int = image_processor(images=lowercase_ , return_tensors="pt" ).to(lowercase_ ) # forward pass with torch.no_grad(): UpperCAmelCase_ : Dict = model(**lowercase_ ) # verify the logits UpperCAmelCase_ : List[str] = torch.Size((1, 1000) ) self.assertEqual(outputs.logits.shape , lowercase_ ) UpperCAmelCase_ : str = torch.tensor([-1.02_66, 0.19_12, -1.28_61] ).to(lowercase_ ) self.assertTrue(torch.allclose(outputs.logits[0, :3] , lowercase_ , atol=1E-4 ) ) @slow @require_accelerate @require_torch_gpu def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ : List[str] = DeiTModel.from_pretrained( "facebook/deit-base-distilled-patch16-224" , torch_dtype=torch.floataa , device_map="auto" ) UpperCAmelCase_ : str = self.default_image_processor UpperCAmelCase_ : Union[str, Any] = prepare_img() UpperCAmelCase_ : List[Any] = image_processor(images=lowercase_ , return_tensors="pt" ) UpperCAmelCase_ : List[str] = inputs.pixel_values.to(lowercase_ ) # forward pass to make sure inference works in fp16 with torch.no_grad(): UpperCAmelCase_ : int = model(lowercase_ )

import shutil import tempfile import unittest from transformers import SPIECE_UNDERLINE, BatchEncoding, MBartTokenizer, MBartTokenizerFast, is_torch_available from transformers.testing_utils import ( get_tests_dir, nested_simplify, require_sentencepiece, require_tokenizers, require_torch, ) from ...test_tokenization_common import TokenizerTesterMixin __A : Tuple = get_tests_dir('''fixtures/test_sentencepiece.model''') if is_torch_available(): from transformers.models.mbart.modeling_mbart import shift_tokens_right __A : int = 25_0004 __A : Tuple = 25_0020 @require_sentencepiece @require_tokenizers class __A ( lowerCAmelCase , unittest.TestCase ): lowerCAmelCase_ : List[str] = MBartTokenizer lowerCAmelCase_ : List[Any] = MBartTokenizerFast lowerCAmelCase_ : int = True lowerCAmelCase_ : Tuple = True def lowercase__ ( self : int ): super().setUp() # We have a SentencePiece fixture for testing lowerCAmelCase : Any = MBartTokenizer(UpperCAmelCase_ , keep_accents=UpperCAmelCase_ ) tokenizer.save_pretrained(self.tmpdirname ) def lowercase__ ( self : List[Any] ): lowerCAmelCase : Dict = MBartTokenizer(UpperCAmelCase_ , keep_accents=UpperCAmelCase_ ) lowerCAmelCase : List[str] = tokenizer.tokenize('This is a test' ) self.assertListEqual(UpperCAmelCase_ , ['▁This', '▁is', '▁a', '▁t', 'est'] ) self.assertListEqual( tokenizer.convert_tokens_to_ids(UpperCAmelCase_ ) , [value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]] , ) lowerCAmelCase : Dict = tokenizer.tokenize('I was born in 92000, and this is falsé.' ) self.assertListEqual( UpperCAmelCase_ , [ SPIECE_UNDERLINE + 'I', SPIECE_UNDERLINE + 'was', SPIECE_UNDERLINE + 'b', 'or', 'n', SPIECE_UNDERLINE + 'in', SPIECE_UNDERLINE + '', '9', '2', '0', '0', '0', ',', SPIECE_UNDERLINE + 'and', SPIECE_UNDERLINE + 'this', SPIECE_UNDERLINE + 'is', SPIECE_UNDERLINE + 'f', 'al', 's', 'é', '.', ] , ) lowerCAmelCase : Dict = tokenizer.convert_tokens_to_ids(UpperCAmelCase_ ) self.assertListEqual( UpperCAmelCase_ , [ value + tokenizer.fairseq_offset for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4] # ^ unk: 2 + 1 = 3 unk: 2 + 1 = 3 ^ ] , ) lowerCAmelCase : Any = tokenizer.convert_ids_to_tokens(UpperCAmelCase_ ) self.assertListEqual( UpperCAmelCase_ , [ SPIECE_UNDERLINE + 'I', SPIECE_UNDERLINE + 'was', SPIECE_UNDERLINE + 'b', 'or', 'n', SPIECE_UNDERLINE + 'in', SPIECE_UNDERLINE + '', '<unk>', '2', '0', '0', '0', ',', SPIECE_UNDERLINE + 'and', SPIECE_UNDERLINE + 'this', SPIECE_UNDERLINE + 'is', SPIECE_UNDERLINE + 'f', 'al', 's', '<unk>', '.', ] , ) def lowercase__ ( self : Tuple ): if not self.test_slow_tokenizer: # as we don't have a slow version, we can't compare the outputs between slow and fast versions return lowerCAmelCase : str = (self.rust_tokenizer_class, 'hf-internal-testing/tiny-random-mbart', {}) for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})" ): lowerCAmelCase : int = self.rust_tokenizer_class.from_pretrained(UpperCAmelCase_ , **UpperCAmelCase_ ) lowerCAmelCase : Optional[int] = self.tokenizer_class.from_pretrained(UpperCAmelCase_ , **UpperCAmelCase_ ) lowerCAmelCase : int = tempfile.mkdtemp() lowerCAmelCase : Tuple = tokenizer_r.save_pretrained(UpperCAmelCase_ ) lowerCAmelCase : Tuple = tokenizer_p.save_pretrained(UpperCAmelCase_ ) # Checks it save with the same files + the tokenizer.json file for the fast one self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files ) ) lowerCAmelCase : List[Any] = tuple(f for f in tokenizer_r_files if 'tokenizer.json' not in f ) self.assertSequenceEqual(UpperCAmelCase_ , UpperCAmelCase_ ) # Checks everything loads correctly in the same way lowerCAmelCase : List[str] = tokenizer_r.from_pretrained(UpperCAmelCase_ ) lowerCAmelCase : List[Any] = tokenizer_p.from_pretrained(UpperCAmelCase_ ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(UpperCAmelCase_ , UpperCAmelCase_ ) ) # self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key)) # self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id")) shutil.rmtree(UpperCAmelCase_ ) # Save tokenizer rust, legacy_format=True lowerCAmelCase : List[Any] = tempfile.mkdtemp() lowerCAmelCase : int = tokenizer_r.save_pretrained(UpperCAmelCase_ , legacy_format=UpperCAmelCase_ ) lowerCAmelCase : Dict = tokenizer_p.save_pretrained(UpperCAmelCase_ ) # Checks it save with the same files self.assertSequenceEqual(UpperCAmelCase_ , UpperCAmelCase_ ) # Checks everything loads correctly in the same way lowerCAmelCase : List[str] = tokenizer_r.from_pretrained(UpperCAmelCase_ ) lowerCAmelCase : List[str] = tokenizer_p.from_pretrained(UpperCAmelCase_ ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(UpperCAmelCase_ , UpperCAmelCase_ ) ) shutil.rmtree(UpperCAmelCase_ ) # Save tokenizer rust, legacy_format=False lowerCAmelCase : Optional[Any] = tempfile.mkdtemp() lowerCAmelCase : Union[str, Any] = tokenizer_r.save_pretrained(UpperCAmelCase_ , legacy_format=UpperCAmelCase_ ) lowerCAmelCase : Tuple = tokenizer_p.save_pretrained(UpperCAmelCase_ ) # Checks it saved the tokenizer.json file self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files ) ) # Checks everything loads correctly in the same way lowerCAmelCase : Optional[int] = tokenizer_r.from_pretrained(UpperCAmelCase_ ) lowerCAmelCase : List[Any] = tokenizer_p.from_pretrained(UpperCAmelCase_ ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(UpperCAmelCase_ , UpperCAmelCase_ ) ) shutil.rmtree(UpperCAmelCase_ ) @require_torch @require_sentencepiece @require_tokenizers class __A ( unittest.TestCase ): lowerCAmelCase_ : str = "facebook/mbart-large-en-ro" lowerCAmelCase_ : List[Any] = [ " UN Chief Says There Is No Military Solution in Syria", " Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.", ] lowerCAmelCase_ : Any = [ "Şeful ONU declară că nu există o soluţie militară în Siria", "Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei" " pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor" " face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.", ] lowerCAmelCase_ : List[Any] = [8274, 12_7873, 2_5916, 7, 8622, 2071, 438, 6_7485, 53, 18_7895, 23, 5_1712, 2, EN_CODE] @classmethod def lowercase__ ( cls : int ): lowerCAmelCase : MBartTokenizer = MBartTokenizer.from_pretrained( cls.checkpoint_name , src_lang='en_XX' , tgt_lang='ro_RO' ) lowerCAmelCase : int = 1 return cls def lowercase__ ( self : str ): self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ar_AR'] , 250001 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['en_EN'] , 250004 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ro_RO'] , 250020 ) def lowercase__ ( self : str ): lowerCAmelCase : str = self.tokenizer.batch_encode_plus(self.src_text ).input_ids[0] self.assertListEqual(self.expected_src_tokens , UpperCAmelCase_ ) def lowercase__ ( self : int ): self.assertIn(UpperCAmelCase_ , self.tokenizer.all_special_ids ) lowerCAmelCase : Optional[int] = [RO_CODE, 884, 9019, 96, 9, 916, 86792, 36, 18743, 15596, 5, 2] lowerCAmelCase : List[str] = self.tokenizer.decode(UpperCAmelCase_ , skip_special_tokens=UpperCAmelCase_ ) lowerCAmelCase : str = self.tokenizer.decode(generated_ids[1:] , skip_special_tokens=UpperCAmelCase_ ) self.assertEqual(UpperCAmelCase_ , UpperCAmelCase_ ) self.assertNotIn(self.tokenizer.eos_token , UpperCAmelCase_ ) def lowercase__ ( self : List[str] ): lowerCAmelCase : int = ['this is gunna be a long sentence ' * 20] assert isinstance(src_text[0] , UpperCAmelCase_ ) lowerCAmelCase : Any = 10 lowerCAmelCase : str = self.tokenizer(UpperCAmelCase_ , max_length=UpperCAmelCase_ , truncation=UpperCAmelCase_ ).input_ids[0] self.assertEqual(ids[-2] , 2 ) self.assertEqual(ids[-1] , UpperCAmelCase_ ) self.assertEqual(len(UpperCAmelCase_ ) , UpperCAmelCase_ ) def lowercase__ ( self : Optional[Any] ): self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['<mask>', 'ar_AR'] ) , [250026, 250001] ) def lowercase__ ( self : Optional[Any] ): lowerCAmelCase : Any = tempfile.mkdtemp() lowerCAmelCase : Union[str, Any] = self.tokenizer.fairseq_tokens_to_ids self.tokenizer.save_pretrained(UpperCAmelCase_ ) lowerCAmelCase : Union[str, Any] = MBartTokenizer.from_pretrained(UpperCAmelCase_ ) self.assertDictEqual(new_tok.fairseq_tokens_to_ids , UpperCAmelCase_ ) @require_torch def lowercase__ ( self : Optional[int] ): lowerCAmelCase : int = self.tokenizer(self.src_text , text_target=self.tgt_text , padding=UpperCAmelCase_ , return_tensors='pt' ) lowerCAmelCase : str = shift_tokens_right(batch['labels'] , self.tokenizer.pad_token_id ) # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4 assert batch.input_ids[1][-2:].tolist() == [2, EN_CODE] assert batch.decoder_input_ids[1][0].tolist() == RO_CODE assert batch.decoder_input_ids[1][-1] == 2 assert batch.labels[1][-2:].tolist() == [2, RO_CODE] @require_torch def lowercase__ ( self : Any ): lowerCAmelCase : Tuple = self.tokenizer( self.src_text , text_target=self.tgt_text , padding=UpperCAmelCase_ , truncation=UpperCAmelCase_ , max_length=len(self.expected_src_tokens ) , return_tensors='pt' , ) lowerCAmelCase : Optional[int] = shift_tokens_right(batch['labels'] , self.tokenizer.pad_token_id ) self.assertIsInstance(UpperCAmelCase_ , UpperCAmelCase_ ) self.assertEqual((2, 14) , batch.input_ids.shape ) self.assertEqual((2, 14) , batch.attention_mask.shape ) lowerCAmelCase : Optional[Any] = batch.input_ids.tolist()[0] self.assertListEqual(self.expected_src_tokens , UpperCAmelCase_ ) self.assertEqual(2 , batch.decoder_input_ids[0, -1] ) # EOS # Test that special tokens are reset self.assertEqual(self.tokenizer.prefix_tokens , [] ) self.assertEqual(self.tokenizer.suffix_tokens , [self.tokenizer.eos_token_id, EN_CODE] ) def lowercase__ ( self : Union[str, Any] ): lowerCAmelCase : Optional[int] = self.tokenizer(self.src_text , padding=UpperCAmelCase_ , truncation=UpperCAmelCase_ , max_length=3 , return_tensors='pt' ) lowerCAmelCase : Any = self.tokenizer( text_target=self.tgt_text , padding=UpperCAmelCase_ , truncation=UpperCAmelCase_ , max_length=10 , return_tensors='pt' ) lowerCAmelCase : List[Any] = targets['input_ids'] lowerCAmelCase : List[str] = shift_tokens_right(UpperCAmelCase_ , self.tokenizer.pad_token_id ) self.assertEqual(batch.input_ids.shape[1] , 3 ) self.assertEqual(batch.decoder_input_ids.shape[1] , 10 ) @require_torch def lowercase__ ( self : str ): lowerCAmelCase : Tuple = self.tokenizer._build_translation_inputs( 'A test' , return_tensors='pt' , src_lang='en_XX' , tgt_lang='ar_AR' ) self.assertEqual( nested_simplify(UpperCAmelCase_ ) , { # A, test, EOS, en_XX 'input_ids': [[62, 3034, 2, 250004]], 'attention_mask': [[1, 1, 1, 1]], # ar_AR 'forced_bos_token_id': 250001, } , )

from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, ) __A : Optional[Any] = {'''configuration_unispeech''': ['''UNISPEECH_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''UniSpeechConfig''']} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A : Any = [ '''UNISPEECH_PRETRAINED_MODEL_ARCHIVE_LIST''', '''UniSpeechForCTC''', '''UniSpeechForPreTraining''', '''UniSpeechForSequenceClassification''', '''UniSpeechModel''', '''UniSpeechPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_unispeech import UNISPEECH_PRETRAINED_CONFIG_ARCHIVE_MAP, UniSpeechConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_unispeech import ( UNISPEECH_PRETRAINED_MODEL_ARCHIVE_LIST, UniSpeechForCTC, UniSpeechForPreTraining, UniSpeechForSequenceClassification, UniSpeechModel, UniSpeechPreTrainedModel, ) else: import sys __A : Union[str, Any] = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

"""simple docstring""" from __future__ import annotations import math def __UpperCAmelCase ( __UpperCamelCase , __UpperCamelCase ): if len(__SCREAMING_SNAKE_CASE ) != 2 or len(a[0] ) != 2 or len(__SCREAMING_SNAKE_CASE ) != 2 or len(b[0] ) != 2: raise Exception('''Matrices are not 2x2''' ) __lowercase : Tuple = [ [a[0][0] * b[0][0] + a[0][1] * b[1][0], a[0][0] * b[0][1] + a[0][1] * b[1][1]], [a[1][0] * b[0][0] + a[1][1] * b[1][0], a[1][0] * b[0][1] + a[1][1] * b[1][1]], ] return new_matrix def __UpperCAmelCase ( __UpperCamelCase , __UpperCamelCase ): return [ [matrix_a[row][col] + matrix_b[row][col] for col in range(len(matrix_a[row] ) )] for row in range(len(__SCREAMING_SNAKE_CASE ) ) ] def __UpperCAmelCase ( __UpperCamelCase , __UpperCamelCase ): return [ [matrix_a[row][col] - matrix_b[row][col] for col in range(len(matrix_a[row] ) )] for row in range(len(__SCREAMING_SNAKE_CASE ) ) ] def __UpperCAmelCase ( __UpperCamelCase ): if len(__SCREAMING_SNAKE_CASE ) % 2 != 0 or len(a[0] ) % 2 != 0: raise Exception('''Odd matrices are not supported!''' ) __lowercase : Dict = len(__SCREAMING_SNAKE_CASE ) __lowercase : int = matrix_length // 2 __lowercase : int = [[a[i][j] for j in range(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE )] for i in range(__SCREAMING_SNAKE_CASE )] __lowercase : List[Any] = [ [a[i][j] for j in range(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE )] for i in range(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) ] __lowercase : str = [[a[i][j] for j in range(__SCREAMING_SNAKE_CASE )] for i in range(__SCREAMING_SNAKE_CASE )] __lowercase : List[Any] = [[a[i][j] for j in range(__SCREAMING_SNAKE_CASE )] for i in range(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE )] return top_left, top_right, bot_left, bot_right def __UpperCAmelCase ( __UpperCamelCase ): return len(__SCREAMING_SNAKE_CASE ), len(matrix[0] ) def __UpperCAmelCase ( __UpperCamelCase ): print('''\n'''.join(str(__SCREAMING_SNAKE_CASE ) for line in matrix ) ) def __UpperCAmelCase ( __UpperCamelCase , __UpperCamelCase ): if matrix_dimensions(__SCREAMING_SNAKE_CASE ) == (2, 2): return default_matrix_multiplication(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) __lowercase : Any = split_matrix(__SCREAMING_SNAKE_CASE ) __lowercase : int = split_matrix(__SCREAMING_SNAKE_CASE ) __lowercase : Dict = actual_strassen(__SCREAMING_SNAKE_CASE , matrix_subtraction(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) ) __lowercase : Union[str, Any] = actual_strassen(matrix_addition(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , __SCREAMING_SNAKE_CASE ) __lowercase : int = actual_strassen(matrix_addition(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , __SCREAMING_SNAKE_CASE ) __lowercase : Optional[Any] = actual_strassen(__SCREAMING_SNAKE_CASE , matrix_subtraction(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) ) __lowercase : str = actual_strassen(matrix_addition(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , matrix_addition(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) ) __lowercase : List[str] = actual_strassen(matrix_subtraction(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , matrix_addition(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) ) __lowercase : Any = actual_strassen(matrix_subtraction(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , matrix_addition(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) ) __lowercase : Optional[int] = matrix_addition(matrix_subtraction(matrix_addition(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , __SCREAMING_SNAKE_CASE ) , __SCREAMING_SNAKE_CASE ) __lowercase : Optional[int] = matrix_addition(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) __lowercase : Optional[Any] = matrix_addition(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) __lowercase : Union[str, Any] = matrix_subtraction(matrix_subtraction(matrix_addition(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , __SCREAMING_SNAKE_CASE ) , __SCREAMING_SNAKE_CASE ) # construct the new matrix from our 4 quadrants __lowercase : Union[str, Any] = [] for i in range(len(__SCREAMING_SNAKE_CASE ) ): new_matrix.append(top_left[i] + top_right[i] ) for i in range(len(__SCREAMING_SNAKE_CASE ) ): new_matrix.append(bot_left[i] + bot_right[i] ) return new_matrix def __UpperCAmelCase ( __UpperCamelCase , __UpperCamelCase ): if matrix_dimensions(__SCREAMING_SNAKE_CASE )[1] != matrix_dimensions(__SCREAMING_SNAKE_CASE )[0]: __lowercase : Any = ( "Unable to multiply these matrices, please check the dimensions.\n" f"""Matrix A: {matrixa}\n""" f"""Matrix B: {matrixa}""" ) raise Exception(__SCREAMING_SNAKE_CASE ) __lowercase : Union[str, Any] = matrix_dimensions(__SCREAMING_SNAKE_CASE ) __lowercase : Tuple = matrix_dimensions(__SCREAMING_SNAKE_CASE ) if dimensiona[0] == dimensiona[1] and dimensiona[0] == dimensiona[1]: return [matrixa, matrixa] __lowercase : int = max(*__SCREAMING_SNAKE_CASE , *__SCREAMING_SNAKE_CASE ) __lowercase : Any = int(math.pow(2 , math.ceil(math.loga(__SCREAMING_SNAKE_CASE ) ) ) ) __lowercase : int = matrixa __lowercase : Union[str, Any] = matrixa # Adding zeros to the matrices so that the arrays dimensions are the same and also # power of 2 for i in range(0 , __SCREAMING_SNAKE_CASE ): if i < dimensiona[0]: for _ in range(dimensiona[1] , __SCREAMING_SNAKE_CASE ): new_matrixa[i].append(0 ) else: new_matrixa.append([0] * maxim ) if i < dimensiona[0]: for _ in range(dimensiona[1] , __SCREAMING_SNAKE_CASE ): new_matrixa[i].append(0 ) else: new_matrixa.append([0] * maxim ) __lowercase : List[Any] = actual_strassen(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) # Removing the additional zeros for i in range(0 , __SCREAMING_SNAKE_CASE ): if i < dimensiona[0]: for _ in range(dimensiona[1] , __SCREAMING_SNAKE_CASE ): final_matrix[i].pop() else: final_matrix.pop() return final_matrix if __name__ == "__main__": a_ = [ [2, 3, 4, 5], [6, 4, 3, 1], [2, 3, 6, 7], [3, 1, 2, 4], [2, 3, 4, 5], [6, 4, 3, 1], [2, 3, 6, 7], [3, 1, 2, 4], [2, 3, 4, 5], [6, 2, 3, 1], ] a_ = [[0, 2, 1, 1], [1_6, 2, 3, 3], [2, 2, 7, 7], [1_3, 1_1, 2_2, 4]] print(strassen(matrixa, matrixa))

"""simple docstring""" import pickle import numpy as np from matplotlib import pyplot as plt class snake_case : def __init__( self : int , UpperCamelCase__ : Optional[Any] , UpperCamelCase__ : Optional[int] , UpperCamelCase__ : List[str] , UpperCamelCase__ : List[str] , UpperCamelCase__ : Dict , UpperCamelCase__ : Union[str, Any]=0.2 , UpperCamelCase__ : Any=0.2)-> Optional[int]: '''simple docstring''' __lowerCAmelCase: Optional[Any] = bp_numa __lowerCAmelCase: Optional[int] = bp_numa __lowerCAmelCase: Tuple = bp_numa __lowerCAmelCase: Optional[int] = conva_get[:2] __lowerCAmelCase: int = conva_get[2] __lowerCAmelCase: List[str] = size_pa __lowerCAmelCase: Tuple = rate_w __lowerCAmelCase: Dict = rate_t __lowerCAmelCase: List[Any] = [ np.mat(-1 * np.random.rand(self.conva[0] , self.conva[0]) + 0.5) for i in range(self.conva[1]) ] __lowerCAmelCase: Union[str, Any] = np.mat(-1 * np.random.rand(self.num_bpa , self.num_bpa) + 0.5) __lowerCAmelCase: int = np.mat(-1 * np.random.rand(self.num_bpa , self.num_bpa) + 0.5) __lowerCAmelCase: Optional[Any] = -2 * np.random.rand(self.conva[1]) + 1 __lowerCAmelCase: int = -2 * np.random.rand(self.num_bpa) + 1 __lowerCAmelCase: str = -2 * np.random.rand(self.num_bpa) + 1 def lowercase_ ( self : Optional[int] , UpperCamelCase__ : int)-> List[str]: '''simple docstring''' __lowerCAmelCase: Any = { "num_bp1": self.num_bpa, "num_bp2": self.num_bpa, "num_bp3": self.num_bpa, "conv1": self.conva, "step_conv1": self.step_conva, "size_pooling1": self.size_poolinga, "rate_weight": self.rate_weight, "rate_thre": self.rate_thre, "w_conv1": self.w_conva, "wkj": self.wkj, "vji": self.vji, "thre_conv1": self.thre_conva, "thre_bp2": self.thre_bpa, "thre_bp3": self.thre_bpa, } with open(UpperCamelCase__ , "wb") as f: pickle.dump(UpperCamelCase__ , UpperCamelCase__) print(f"Model saved： {save_path}") @classmethod def lowercase_ ( cls : Dict , UpperCamelCase__ : Union[str, Any])-> List[Any]: '''simple docstring''' with open(UpperCamelCase__ , "rb") as f: __lowerCAmelCase: Dict = pickle.load(UpperCamelCase__) # noqa: S301 __lowerCAmelCase: Optional[int] = model_dic.get("conv1") conv_get.append(model_dic.get("step_conv1")) __lowerCAmelCase: List[str] = model_dic.get("size_pooling1") __lowerCAmelCase: Union[str, Any] = model_dic.get("num_bp1") __lowerCAmelCase: Any = model_dic.get("num_bp2") __lowerCAmelCase: Union[str, Any] = model_dic.get("num_bp3") __lowerCAmelCase: Optional[int] = model_dic.get("rate_weight") __lowerCAmelCase: int = model_dic.get("rate_thre") # create model instance __lowerCAmelCase: Tuple = CNN(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__) # modify model parameter __lowerCAmelCase: Any = model_dic.get("w_conv1") __lowerCAmelCase: Optional[Any] = model_dic.get("wkj") __lowerCAmelCase: Any = model_dic.get("vji") __lowerCAmelCase: Dict = model_dic.get("thre_conv1") __lowerCAmelCase: int = model_dic.get("thre_bp2") __lowerCAmelCase: Optional[int] = model_dic.get("thre_bp3") return conv_ins def lowercase_ ( self : Dict , UpperCamelCase__ : List[Any])-> List[Any]: '''simple docstring''' return 1 / (1 + np.exp(-1 * x)) def lowercase_ ( self : Dict , UpperCamelCase__ : List[Any])-> Optional[Any]: '''simple docstring''' return round(UpperCamelCase__ , 3) def lowercase_ ( self : Optional[int] , UpperCamelCase__ : Optional[int] , UpperCamelCase__ : Any , UpperCamelCase__ : List[str] , UpperCamelCase__ : Tuple , UpperCamelCase__ : int)-> Dict: '''simple docstring''' __lowerCAmelCase: List[Any] = convs[0] __lowerCAmelCase: int = convs[1] __lowerCAmelCase: Union[str, Any] = np.shape(UpperCamelCase__)[0] # get the data slice of original image data, data_focus __lowerCAmelCase: Optional[Any] = [] for i_focus in range(0 , size_data - size_conv + 1 , UpperCamelCase__): for j_focus in range(0 , size_data - size_conv + 1 , UpperCamelCase__): __lowerCAmelCase: Union[str, Any] = data[ i_focus : i_focus + size_conv, j_focus : j_focus + size_conv ] data_focus.append(UpperCamelCase__) # calculate the feature map of every single kernel, and saved as list of matrix __lowerCAmelCase: int = [] __lowerCAmelCase: Optional[int] = int((size_data - size_conv) / conv_step + 1) for i_map in range(UpperCamelCase__): __lowerCAmelCase: List[str] = [] for i_focus in range(len(UpperCamelCase__)): __lowerCAmelCase: Union[str, Any] = ( np.sum(np.multiply(data_focus[i_focus] , w_convs[i_map])) - thre_convs[i_map] ) featuremap.append(self.sig(UpperCamelCase__)) __lowerCAmelCase: str = np.asmatrix(UpperCamelCase__).reshape( UpperCamelCase__ , UpperCamelCase__) data_featuremap.append(UpperCamelCase__) # expanding the data slice to One dimenssion __lowerCAmelCase: Optional[Any] = [] for each_focus in data_focus: focusa_list.extend(self.Expand_Mat(UpperCamelCase__)) __lowerCAmelCase: List[Any] = np.asarray(UpperCamelCase__) return focus_list, data_featuremap def lowercase_ ( self : Any , UpperCamelCase__ : List[str] , UpperCamelCase__ : List[Any] , UpperCamelCase__ : Optional[Any]="average_pool")-> str: '''simple docstring''' __lowerCAmelCase: Tuple = len(featuremaps[0]) __lowerCAmelCase: List[Any] = int(size_map / size_pooling) __lowerCAmelCase: int = [] for i_map in range(len(UpperCamelCase__)): __lowerCAmelCase: str = featuremaps[i_map] __lowerCAmelCase: List[Any] = [] for i_focus in range(0 , UpperCamelCase__ , UpperCamelCase__): for j_focus in range(0 , UpperCamelCase__ , UpperCamelCase__): __lowerCAmelCase: Any = feature_map[ i_focus : i_focus + size_pooling, j_focus : j_focus + size_pooling, ] if pooling_type == "average_pool": # average pooling map_pooled.append(np.average(UpperCamelCase__)) elif pooling_type == "max_pooling": # max pooling map_pooled.append(np.max(UpperCamelCase__)) __lowerCAmelCase: Optional[int] = np.asmatrix(UpperCamelCase__).reshape(UpperCamelCase__ , UpperCamelCase__) featuremap_pooled.append(UpperCamelCase__) return featuremap_pooled def lowercase_ ( self : Union[str, Any] , UpperCamelCase__ : str)-> int: '''simple docstring''' __lowerCAmelCase: List[Any] = [] for i in range(len(UpperCamelCase__)): __lowerCAmelCase: Union[str, Any] = np.shape(data[i]) __lowerCAmelCase: int = data[i].reshape(1 , shapes[0] * shapes[1]) __lowerCAmelCase: Dict = data_listed.getA().tolist()[0] data_expanded.extend(UpperCamelCase__) __lowerCAmelCase: Any = np.asarray(UpperCamelCase__) return data_expanded def lowercase_ ( self : Union[str, Any] , UpperCamelCase__ : Union[str, Any])-> Optional[Any]: '''simple docstring''' __lowerCAmelCase: Dict = np.asarray(UpperCamelCase__) __lowerCAmelCase: Optional[int] = np.shape(UpperCamelCase__) __lowerCAmelCase: Optional[int] = data_mat.reshape(1 , shapes[0] * shapes[1]) return data_expanded def lowercase_ ( self : Dict , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Dict , UpperCamelCase__ : Optional[Any] , UpperCamelCase__ : List[Any] , UpperCamelCase__ : Dict)-> List[Any]: '''simple docstring''' __lowerCAmelCase: Optional[int] = [] __lowerCAmelCase: Any = 0 for i_map in range(UpperCamelCase__): __lowerCAmelCase: Optional[Any] = np.ones((size_map, size_map)) for i in range(0 , UpperCamelCase__ , UpperCamelCase__): for j in range(0 , UpperCamelCase__ , UpperCamelCase__): __lowerCAmelCase: Optional[Any] = pd_pool[ i_pool ] __lowerCAmelCase: str = i_pool + 1 __lowerCAmelCase: Dict = np.multiply( UpperCamelCase__ , np.multiply(out_map[i_map] , (1 - out_map[i_map]))) pd_all.append(UpperCamelCase__) return pd_all def lowercase_ ( self : str , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : int , UpperCamelCase__ : Dict , UpperCamelCase__ : List[Any] , UpperCamelCase__ : Any , UpperCamelCase__ : str=bool)-> List[str]: '''simple docstring''' print("----------------------Start Training-------------------------") print((" - - Shape: Train_Data ", np.shape(UpperCamelCase__))) print((" - - Shape: Teach_Data ", np.shape(UpperCamelCase__))) __lowerCAmelCase: str = 0 __lowerCAmelCase: Optional[int] = [] __lowerCAmelCase: List[Any] = 1_0_0_0_0 while rp < n_repeat and mse >= error_accuracy: __lowerCAmelCase: Optional[Any] = 0 print(f"-------------Learning Time {rp}--------------") for p in range(len(UpperCamelCase__)): # print('------------Learning Image: %d--------------'%p) __lowerCAmelCase: Dict = np.asmatrix(datas_train[p]) __lowerCAmelCase: Dict = np.asarray(datas_teach[p]) __lowerCAmelCase , __lowerCAmelCase: int = self.convolute( UpperCamelCase__ , self.conva , self.w_conva , self.thre_conva , conv_step=self.step_conva , ) __lowerCAmelCase: Any = self.pooling(UpperCamelCase__ , self.size_poolinga) __lowerCAmelCase: Optional[Any] = np.shape(UpperCamelCase__) __lowerCAmelCase: str = self._expand(UpperCamelCase__) __lowerCAmelCase: str = data_bp_input __lowerCAmelCase: int = np.dot(UpperCamelCase__ , self.vji.T) - self.thre_bpa __lowerCAmelCase: int = self.sig(UpperCamelCase__) __lowerCAmelCase: Optional[Any] = np.dot(UpperCamelCase__ , self.wkj.T) - self.thre_bpa __lowerCAmelCase: str = self.sig(UpperCamelCase__) # --------------Model Leaning ------------------------ # calculate error and gradient--------------- __lowerCAmelCase: Union[str, Any] = np.multiply( (data_teach - bp_outa) , np.multiply(UpperCamelCase__ , (1 - bp_outa))) __lowerCAmelCase: Any = np.multiply( np.dot(UpperCamelCase__ , self.wkj) , np.multiply(UpperCamelCase__ , (1 - bp_outa))) __lowerCAmelCase: str = np.dot(UpperCamelCase__ , self.vji) __lowerCAmelCase: Union[str, Any] = pd_i_all / (self.size_poolinga * self.size_poolinga) __lowerCAmelCase: str = pd_conva_pooled.T.getA().tolist() __lowerCAmelCase: str = self._calculate_gradient_from_pool( UpperCamelCase__ , UpperCamelCase__ , shape_featuremapa[0] , shape_featuremapa[1] , self.size_poolinga , ) # weight and threshold learning process--------- # convolution layer for k_conv in range(self.conva[1]): __lowerCAmelCase: List[Any] = self._expand_mat(pd_conva_all[k_conv]) __lowerCAmelCase: int = self.rate_weight * np.dot(UpperCamelCase__ , UpperCamelCase__) __lowerCAmelCase: Tuple = self.w_conva[k_conv] + delta_w.reshape( (self.conva[0], self.conva[0])) __lowerCAmelCase: Tuple = ( self.thre_conva[k_conv] - np.sum(pd_conva_all[k_conv]) * self.rate_thre ) # all connected layer __lowerCAmelCase: List[Any] = self.wkj + pd_k_all.T * bp_outa * self.rate_weight __lowerCAmelCase: Union[str, Any] = self.vji + pd_j_all.T * bp_outa * self.rate_weight __lowerCAmelCase: Tuple = self.thre_bpa - pd_k_all * self.rate_thre __lowerCAmelCase: Optional[int] = self.thre_bpa - pd_j_all * self.rate_thre # calculate the sum error of all single image __lowerCAmelCase: List[str] = np.sum(abs(data_teach - bp_outa)) error_count += errors # print(' ----Teach ',data_teach) # print(' ----BP_output ',bp_out3) __lowerCAmelCase: Tuple = rp + 1 __lowerCAmelCase: Optional[Any] = error_count / patterns all_mse.append(UpperCamelCase__) def draw_error(): __lowerCAmelCase: Dict = [error_accuracy for i in range(int(n_repeat * 1.2))] plt.plot(UpperCamelCase__ , "+-") plt.plot(UpperCamelCase__ , "r--") plt.xlabel("Learning Times") plt.ylabel("All_mse") plt.grid(UpperCamelCase__ , alpha=0.5) plt.show() print("------------------Training Complished---------------------") print((" - - Training epoch: ", rp, f" - - Mse: {mse:.6f}")) if draw_e: draw_error() return mse def lowercase_ ( self : Union[str, Any] , UpperCamelCase__ : Tuple)-> List[str]: '''simple docstring''' __lowerCAmelCase: int = [] print("-------------------Start Testing-------------------------") print((" - - Shape: Test_Data ", np.shape(UpperCamelCase__))) for p in range(len(UpperCamelCase__)): __lowerCAmelCase: Dict = np.asmatrix(datas_test[p]) __lowerCAmelCase , __lowerCAmelCase: Optional[int] = self.convolute( UpperCamelCase__ , self.conva , self.w_conva , self.thre_conva , conv_step=self.step_conva , ) __lowerCAmelCase: Tuple = self.pooling(UpperCamelCase__ , self.size_poolinga) __lowerCAmelCase: List[str] = self._expand(UpperCamelCase__) __lowerCAmelCase: int = data_bp_input __lowerCAmelCase: List[Any] = bp_outa * self.vji.T - self.thre_bpa __lowerCAmelCase: Any = self.sig(UpperCamelCase__) __lowerCAmelCase: Union[str, Any] = bp_outa * self.wkj.T - self.thre_bpa __lowerCAmelCase: List[str] = self.sig(UpperCamelCase__) produce_out.extend(bp_outa.getA().tolist()) __lowerCAmelCase: Tuple = [list(map(self.do_round , UpperCamelCase__)) for each in produce_out] return np.asarray(UpperCamelCase__) def lowercase_ ( self : int , UpperCamelCase__ : Any)-> Any: '''simple docstring''' __lowerCAmelCase: Union[str, Any] = np.asmatrix(UpperCamelCase__) __lowerCAmelCase , __lowerCAmelCase: Optional[Any] = self.convolute( UpperCamelCase__ , self.conva , self.w_conva , self.thre_conva , conv_step=self.step_conva , ) __lowerCAmelCase: Any = self.pooling(UpperCamelCase__ , self.size_poolinga) return data_conveda, data_pooleda if __name__ == "__main__": pass

'''simple docstring''' from ...configuration_utils import PretrainedConfig from ...utils import logging A : Tuple = logging.get_logger(__name__) A : str = { '''unc-nlp/lxmert-base-uncased''': '''https://huggingface.co/unc-nlp/lxmert-base-uncased/resolve/main/config.json''', } class __lowerCamelCase ( a_ ): """simple docstring""" a = "lxmert" a = {} def __init__( self : str , SCREAMING_SNAKE_CASE : Any=30522 , SCREAMING_SNAKE_CASE : Optional[int]=768 , SCREAMING_SNAKE_CASE : Optional[int]=12 , SCREAMING_SNAKE_CASE : Optional[Any]=9500 , SCREAMING_SNAKE_CASE : Optional[Any]=1600 , SCREAMING_SNAKE_CASE : List[str]=400 , SCREAMING_SNAKE_CASE : int=3072 , SCREAMING_SNAKE_CASE : str="gelu" , SCREAMING_SNAKE_CASE : Tuple=0.1 , SCREAMING_SNAKE_CASE : Optional[int]=0.1 , SCREAMING_SNAKE_CASE : Any=512 , SCREAMING_SNAKE_CASE : List[str]=2 , SCREAMING_SNAKE_CASE : Optional[Any]=0.02 , SCREAMING_SNAKE_CASE : Dict=1e-12 , SCREAMING_SNAKE_CASE : Any=9 , SCREAMING_SNAKE_CASE : List[str]=5 , SCREAMING_SNAKE_CASE : str=5 , SCREAMING_SNAKE_CASE : Any=2048 , SCREAMING_SNAKE_CASE : Optional[int]=4 , SCREAMING_SNAKE_CASE : int=6.67 , SCREAMING_SNAKE_CASE : int=True , SCREAMING_SNAKE_CASE : Dict=True , SCREAMING_SNAKE_CASE : List[str]=True , SCREAMING_SNAKE_CASE : int=True , SCREAMING_SNAKE_CASE : Dict=True , SCREAMING_SNAKE_CASE : int=True , SCREAMING_SNAKE_CASE : Union[str, Any]=True , **SCREAMING_SNAKE_CASE : Any , ): _A : int = vocab_size _A : List[Any] = hidden_size _A : Dict = num_attention_heads _A : Optional[int] = hidden_act _A : List[str] = intermediate_size _A : Union[str, Any] = hidden_dropout_prob _A : Union[str, Any] = attention_probs_dropout_prob _A : Any = max_position_embeddings _A : int = type_vocab_size _A : Optional[Any] = initializer_range _A : Optional[int] = layer_norm_eps _A : List[str] = num_qa_labels _A : Optional[Any] = num_object_labels _A : Optional[Any] = num_attr_labels _A : Optional[Any] = l_layers _A : Optional[Any] = x_layers _A : Optional[int] = r_layers _A : Optional[Any] = visual_feat_dim _A : int = visual_pos_dim _A : Optional[int] = visual_loss_normalizer _A : Optional[Any] = task_matched _A : Union[str, Any] = task_mask_lm _A : Dict = task_obj_predict _A : List[Any] = task_qa _A : Dict = visual_obj_loss _A : Tuple = visual_attr_loss _A : Any = visual_feat_loss _A : Optional[Any] = {'vision': r_layers, 'cross_encoder': x_layers, 'language': l_layers} super().__init__(**SCREAMING_SNAKE_CASE)

'''simple docstring''' import math from collections import defaultdict from typing import List, Optional, Tuple, Union import numpy as np import torch from ..configuration_utils import ConfigMixin, register_to_config from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin, SchedulerOutput def lowerCAmelCase__ ( lowerCamelCase : int ,lowerCamelCase : str=0.999 ,lowerCamelCase : int="cosine" ,): if alpha_transform_type == "cosine": def alpha_bar_fn(lowerCamelCase : Tuple ): return math.cos((t + 0.008) / 1.008 * math.pi / 2 ) ** 2 elif alpha_transform_type == "exp": def alpha_bar_fn(lowerCamelCase : List[Any] ): return math.exp(t * -12.0 ) else: raise ValueError(F'Unsupported alpha_tranform_type: {alpha_transform_type}' ) _A : Tuple = [] for i in range(lowerCamelCase ): _A : List[Any] = i / num_diffusion_timesteps _A : List[str] = (i + 1) / num_diffusion_timesteps betas.append(min(1 - alpha_bar_fn(lowerCamelCase ) / alpha_bar_fn(lowerCamelCase ) ,lowerCamelCase ) ) return torch.tensor(lowerCamelCase ,dtype=torch.floataa ) class __lowerCamelCase ( a_ , a_ ): """simple docstring""" a = [e.name for e in KarrasDiffusionSchedulers] a = 2 @register_to_config def __init__( self : int , SCREAMING_SNAKE_CASE : int = 1000 , SCREAMING_SNAKE_CASE : float = 0.0_0085 , SCREAMING_SNAKE_CASE : float = 0.012 , SCREAMING_SNAKE_CASE : str = "linear" , SCREAMING_SNAKE_CASE : Optional[Union[np.ndarray, List[float]]] = None , SCREAMING_SNAKE_CASE : str = "epsilon" , SCREAMING_SNAKE_CASE : str = "linspace" , SCREAMING_SNAKE_CASE : int = 0 , ): if trained_betas is not None: _A : Optional[int] = torch.tensor(SCREAMING_SNAKE_CASE , dtype=torch.floataa) elif beta_schedule == "linear": _A : List[Any] = torch.linspace(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , dtype=torch.floataa) elif beta_schedule == "scaled_linear": # this schedule is very specific to the latent diffusion model. _A : Any = ( torch.linspace(beta_start**0.5 , beta_end**0.5 , SCREAMING_SNAKE_CASE , dtype=torch.floataa) ** 2 ) elif beta_schedule == "squaredcos_cap_v2": # Glide cosine schedule _A : Optional[Any] = betas_for_alpha_bar(SCREAMING_SNAKE_CASE) else: raise NotImplementedError(F'{beta_schedule} does is not implemented for {self.__class__}') _A : Any = 1.0 - self.betas _A : List[Any] = torch.cumprod(self.alphas , dim=0) # set all values self.set_timesteps(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE) def A ( self : List[Any] , SCREAMING_SNAKE_CASE : Optional[int] , SCREAMING_SNAKE_CASE : Any=None): if schedule_timesteps is None: _A : Dict = self.timesteps _A : List[Any] = (schedule_timesteps == timestep).nonzero() # The sigma index that is taken for the **very** first `step` # is always the second index (or the last index if there is only 1) # This way we can ensure we don't accidentally skip a sigma in # case we start in the middle of the denoising schedule (e.g. for image-to-image) if len(self._index_counter) == 0: _A : Dict = 1 if len(SCREAMING_SNAKE_CASE) > 1 else 0 else: _A : Union[str, Any] = timestep.cpu().item() if torch.is_tensor(SCREAMING_SNAKE_CASE) else timestep _A : int = self._index_counter[timestep_int] return indices[pos].item() @property def A ( self : Optional[Any]): # standard deviation of the initial noise distribution if self.config.timestep_spacing in ["linspace", "trailing"]: return self.sigmas.max() return (self.sigmas.max() ** 2 + 1) ** 0.5 def A ( self : List[Any] , SCREAMING_SNAKE_CASE : torch.FloatTensor , SCREAMING_SNAKE_CASE : Union[float, torch.FloatTensor] , ): _A : Tuple = self.index_for_timestep(SCREAMING_SNAKE_CASE) if self.state_in_first_order: _A : Any = self.sigmas[step_index] else: _A : int = self.sigmas_interpol[step_index] _A : Union[str, Any] = sample / ((sigma**2 + 1) ** 0.5) return sample def A ( self : Tuple , SCREAMING_SNAKE_CASE : int , SCREAMING_SNAKE_CASE : Union[str, torch.device] = None , SCREAMING_SNAKE_CASE : Optional[int] = None , ): _A : Optional[Any] = num_inference_steps _A : int = num_train_timesteps or self.config.num_train_timesteps # "linspace", "leading", "trailing" corresponds to annotation of Table 2. of https://arxiv.org/abs/2305.08891 if self.config.timestep_spacing == "linspace": _A : Tuple = np.linspace(0 , num_train_timesteps - 1 , SCREAMING_SNAKE_CASE , dtype=SCREAMING_SNAKE_CASE)[::-1].copy() elif self.config.timestep_spacing == "leading": _A : Optional[Any] = num_train_timesteps // self.num_inference_steps # creates integer timesteps by multiplying by ratio # casting to int to avoid issues when num_inference_step is power of 3 _A : int = (np.arange(0 , SCREAMING_SNAKE_CASE) * step_ratio).round()[::-1].copy().astype(SCREAMING_SNAKE_CASE) timesteps += self.config.steps_offset elif self.config.timestep_spacing == "trailing": _A : List[str] = num_train_timesteps / self.num_inference_steps # creates integer timesteps by multiplying by ratio # casting to int to avoid issues when num_inference_step is power of 3 _A : str = (np.arange(SCREAMING_SNAKE_CASE , 0 , -step_ratio)).round().copy().astype(SCREAMING_SNAKE_CASE) timesteps -= 1 else: raise ValueError( F'{self.config.timestep_spacing} is not supported. Please make sure to choose one of \'linspace\', \'leading\' or \'trailing\'.') _A : List[str] = np.array(((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5) _A : Optional[int] = torch.from_numpy(np.log(SCREAMING_SNAKE_CASE)).to(SCREAMING_SNAKE_CASE) _A : str = np.interp(SCREAMING_SNAKE_CASE , np.arange(0 , len(SCREAMING_SNAKE_CASE)) , SCREAMING_SNAKE_CASE) _A : str = np.concatenate([sigmas, [0.0]]).astype(np.floataa) _A : Union[str, Any] = torch.from_numpy(SCREAMING_SNAKE_CASE).to(device=SCREAMING_SNAKE_CASE) # interpolate sigmas _A : Optional[int] = sigmas.log().lerp(sigmas.roll(1).log() , 0.5).exp() _A : Any = torch.cat([sigmas[:1], sigmas[1:].repeat_interleave(2), sigmas[-1:]]) _A : List[Any] = torch.cat( [sigmas_interpol[:1], sigmas_interpol[1:].repeat_interleave(2), sigmas_interpol[-1:]]) if str(SCREAMING_SNAKE_CASE).startswith('mps'): # mps does not support float64 _A : Union[str, Any] = torch.from_numpy(SCREAMING_SNAKE_CASE).to(SCREAMING_SNAKE_CASE , dtype=torch.floataa) else: _A : Dict = torch.from_numpy(SCREAMING_SNAKE_CASE).to(SCREAMING_SNAKE_CASE) # interpolate timesteps _A : Optional[int] = self.sigma_to_t(SCREAMING_SNAKE_CASE).to(SCREAMING_SNAKE_CASE , dtype=timesteps.dtype) _A : Union[str, Any] = torch.stack((timesteps_interpol[1:-1, None], timesteps[1:, None]) , dim=-1).flatten() _A : Optional[Any] = torch.cat([timesteps[:1], interleaved_timesteps]) _A : str = None # for exp beta schedules, such as the one for `pipeline_shap_e.py` # we need an index counter _A : Union[str, Any] = defaultdict(SCREAMING_SNAKE_CASE) def A ( self : Union[str, Any] , SCREAMING_SNAKE_CASE : Union[str, Any]): # get log sigma _A : Dict = sigma.log() # get distribution _A : Any = log_sigma - self.log_sigmas[:, None] # get sigmas range _A : Tuple = dists.ge(0).cumsum(dim=0).argmax(dim=0).clamp(max=self.log_sigmas.shape[0] - 2) _A : Union[str, Any] = low_idx + 1 _A : Dict = self.log_sigmas[low_idx] _A : List[Any] = self.log_sigmas[high_idx] # interpolate sigmas _A : Dict = (low - log_sigma) / (low - high) _A : Union[str, Any] = w.clamp(0 , 1) # transform interpolation to time range _A : int = (1 - w) * low_idx + w * high_idx _A : Any = t.view(sigma.shape) return t @property def A ( self : Any): return self.sample is None def A ( self : int , SCREAMING_SNAKE_CASE : Union[torch.FloatTensor, np.ndarray] , SCREAMING_SNAKE_CASE : Union[float, torch.FloatTensor] , SCREAMING_SNAKE_CASE : Union[torch.FloatTensor, np.ndarray] , SCREAMING_SNAKE_CASE : bool = True , ): _A : Optional[int] = self.index_for_timestep(SCREAMING_SNAKE_CASE) # advance index counter by 1 _A : Dict = timestep.cpu().item() if torch.is_tensor(SCREAMING_SNAKE_CASE) else timestep self._index_counter[timestep_int] += 1 if self.state_in_first_order: _A : Tuple = self.sigmas[step_index] _A : Dict = self.sigmas_interpol[step_index + 1] _A : Union[str, Any] = self.sigmas[step_index + 1] else: # 2nd order / KDPM2's method _A : int = self.sigmas[step_index - 1] _A : Union[str, Any] = self.sigmas_interpol[step_index] _A : Dict = self.sigmas[step_index] # currently only gamma=0 is supported. This usually works best anyways. # We can support gamma in the future but then need to scale the timestep before # passing it to the model which requires a change in API _A : List[Any] = 0 _A : Dict = sigma * (gamma + 1) # Note: sigma_hat == sigma for now # 1. compute predicted original sample (x_0) from sigma-scaled predicted noise if self.config.prediction_type == "epsilon": _A : Tuple = sigma_hat if self.state_in_first_order else sigma_interpol _A : Tuple = sample - sigma_input * model_output elif self.config.prediction_type == "v_prediction": _A : Any = sigma_hat if self.state_in_first_order else sigma_interpol _A : Union[str, Any] = model_output * (-sigma_input / (sigma_input**2 + 1) ** 0.5) + ( sample / (sigma_input**2 + 1) ) elif self.config.prediction_type == "sample": raise NotImplementedError('prediction_type not implemented yet: sample') else: raise ValueError( F'prediction_type given as {self.config.prediction_type} must be one of `epsilon`, or `v_prediction`') if self.state_in_first_order: # 2. Convert to an ODE derivative for 1st order _A : int = (sample - pred_original_sample) / sigma_hat # 3. delta timestep _A : str = sigma_interpol - sigma_hat # store for 2nd order step _A : List[str] = sample else: # DPM-Solver-2 # 2. Convert to an ODE derivative for 2nd order _A : List[Any] = (sample - pred_original_sample) / sigma_interpol # 3. delta timestep _A : Optional[int] = sigma_next - sigma_hat _A : str = self.sample _A : Any = None _A : Tuple = sample + derivative * dt if not return_dict: return (prev_sample,) return SchedulerOutput(prev_sample=SCREAMING_SNAKE_CASE) def A ( self : Any , SCREAMING_SNAKE_CASE : torch.FloatTensor , SCREAMING_SNAKE_CASE : torch.FloatTensor , SCREAMING_SNAKE_CASE : torch.FloatTensor , ): # Make sure sigmas and timesteps have the same device and dtype as original_samples _A : str = self.sigmas.to(device=original_samples.device , dtype=original_samples.dtype) if original_samples.device.type == "mps" and torch.is_floating_point(SCREAMING_SNAKE_CASE): # mps does not support float64 _A : Any = self.timesteps.to(original_samples.device , dtype=torch.floataa) _A : List[str] = timesteps.to(original_samples.device , dtype=torch.floataa) else: _A : str = self.timesteps.to(original_samples.device) _A : str = timesteps.to(original_samples.device) _A : int = [self.index_for_timestep(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE) for t in timesteps] _A : Tuple = sigmas[step_indices].flatten() while len(sigma.shape) < len(original_samples.shape): _A : List[Any] = sigma.unsqueeze(-1) _A : Dict = original_samples + noise * sigma return noisy_samples def __len__( self : List[Any]): return self.config.num_train_timesteps

'''simple docstring''' import numpy as np import skfuzzy as fuzz if __name__ == "__main__": # Create universe of discourse in Python using linspace () UpperCamelCase_ = np.linspace(start=0, stop=75, num=75, endpoint=True, retstep=False) # Create two fuzzy sets by defining any membership function # (trapmf(), gbellmf(), gaussmf(), etc). UpperCamelCase_ = [0, 25, 50] UpperCamelCase_ = [25, 50, 75] UpperCamelCase_ = fuzz.membership.trimf(X, abca) UpperCamelCase_ = fuzz.membership.trimf(X, abca) # Compute the different operations using inbuilt functions. UpperCamelCase_ = np.ones(75) UpperCamelCase_ = np.zeros((75,)) # 1. Union = max(µA(x), µB(x)) UpperCamelCase_ = fuzz.fuzzy_or(X, young, X, middle_aged)[1] # 2. Intersection = min(µA(x), µB(x)) UpperCamelCase_ = fuzz.fuzzy_and(X, young, X, middle_aged)[1] # 3. Complement (A) = (1- min(µA(x)) UpperCamelCase_ = fuzz.fuzzy_not(young) # 4. Difference (A/B) = min(µA(x),(1- µB(x))) UpperCamelCase_ = fuzz.fuzzy_and(X, young, X, fuzz.fuzzy_not(middle_aged)[1])[1] # 5. Algebraic Sum = [µA(x) + µB(x) – (µA(x) * µB(x))] UpperCamelCase_ = young + middle_aged - (young * middle_aged) # 6. Algebraic Product = (µA(x) * µB(x)) UpperCamelCase_ = young * middle_aged # 7. Bounded Sum = min[1,(µA(x), µB(x))] UpperCamelCase_ = fuzz.fuzzy_and(X, one, X, young + middle_aged)[1] # 8. Bounded difference = min[0,(µA(x), µB(x))] UpperCamelCase_ = fuzz.fuzzy_or(X, zero, X, young - middle_aged)[1] # max-min composition # max-product composition # Plot each set A, set B and each operation result using plot() and subplot(). from matplotlib import pyplot as plt plt.figure() plt.subplot(4, 3, 1) plt.plot(X, young) plt.title("""Young""") plt.grid(True) plt.subplot(4, 3, 2) plt.plot(X, middle_aged) plt.title("""Middle aged""") plt.grid(True) plt.subplot(4, 3, 3) plt.plot(X, union) plt.title("""union""") plt.grid(True) plt.subplot(4, 3, 4) plt.plot(X, intersection) plt.title("""intersection""") plt.grid(True) plt.subplot(4, 3, 5) plt.plot(X, complement_a) plt.title("""complement_a""") plt.grid(True) plt.subplot(4, 3, 6) plt.plot(X, difference) plt.title("""difference a/b""") plt.grid(True) plt.subplot(4, 3, 7) plt.plot(X, alg_sum) plt.title("""alg_sum""") plt.grid(True) plt.subplot(4, 3, 8) plt.plot(X, alg_product) plt.title("""alg_product""") plt.grid(True) plt.subplot(4, 3, 9) plt.plot(X, bdd_sum) plt.title("""bdd_sum""") plt.grid(True) plt.subplot(4, 3, 10) plt.plot(X, bdd_difference) plt.title("""bdd_difference""") plt.grid(True) plt.subplots_adjust(hspace=0.5) plt.show()

'''simple docstring''' from typing import TYPE_CHECKING from ...file_utils import _LazyModule, is_tokenizers_available, is_torch_available, is_vision_available from ...utils import OptionalDependencyNotAvailable UpperCamelCase_ = {"""configuration_dpt""": ["""DPT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """DPTConfig"""]} try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCamelCase_ = ["""DPTFeatureExtractor"""] UpperCamelCase_ = ["""DPTImageProcessor"""] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCamelCase_ = [ """DPT_PRETRAINED_MODEL_ARCHIVE_LIST""", """DPTForDepthEstimation""", """DPTForSemanticSegmentation""", """DPTModel""", """DPTPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_dpt import DPT_PRETRAINED_CONFIG_ARCHIVE_MAP, DPTConfig try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_dpt import DPTFeatureExtractor from .image_processing_dpt import DPTImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_dpt import ( DPT_PRETRAINED_MODEL_ARCHIVE_LIST, DPTForDepthEstimation, DPTForSemanticSegmentation, DPTModel, DPTPreTrainedModel, ) else: import sys UpperCamelCase_ = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

'''simple docstring''' import logging import os import random import sys from dataclasses import dataclass, field from typing import Optional import datasets import numpy as np import pandas as pd from datasets import load_dataset import transformers from transformers import ( AutoConfig, BartForSequenceClassification, DataCollatorWithPadding, EvalPrediction, HfArgumentParser, TapexTokenizer, Trainer, TrainingArguments, default_data_collator, set_seed, ) from transformers.trainer_utils import get_last_checkpoint from transformers.utils import check_min_version from transformers.utils.versions import require_version # Will error if the minimal version of Transformers is not installed. Remove at your own risks. check_min_version("""4.17.0.dev0""") require_version("""datasets>=1.8.0""", """To fix: pip install -r examples/pytorch/text-classification/requirements.txt""") a : Tuple = logging.getLogger(__name__) @dataclass class UpperCamelCase_ : lowercase = field( default='tab_fact' , metadata={'help': 'The name of the dataset to use (via the datasets library).'} ) lowercase = field( default='tab_fact' , metadata={'help': 'The configuration name of the dataset to use (via the datasets library).'} , ) lowercase = field( default=1_024 , metadata={ 'help': ( 'The maximum total input sequence length after tokenization. Sequences longer ' 'than this will be truncated, sequences shorter will be padded.' ) } , ) lowercase = field( default=__magic_name__ , metadata={'help': 'Overwrite the cached preprocessed datasets or not.'} ) lowercase = field( default=__magic_name__ , metadata={ 'help': ( 'Whether to pad all samples to `max_seq_length`. ' 'If False, will pad the samples dynamically when batching to the maximum length in the batch.' ) } , ) lowercase = field( default=__magic_name__ , metadata={ 'help': ( 'For debugging purposes or quicker training, truncate the number of training examples to this ' 'value if set.' ) } , ) lowercase = field( default=__magic_name__ , metadata={ 'help': ( 'For debugging purposes or quicker training, truncate the number of evaluation examples to this ' 'value if set.' ) } , ) lowercase = field( default=__magic_name__ , metadata={ 'help': ( 'For debugging purposes or quicker training, truncate the number of prediction examples to this ' 'value if set.' ) } , ) lowercase = field( default=__magic_name__ , metadata={'help': 'A csv or a json file containing the training data.'} ) lowercase = field( default=__magic_name__ , metadata={'help': 'A csv or a json file containing the validation data.'} ) lowercase = field(default=__magic_name__ , metadata={'help': 'A csv or a json file containing the test data.'} ) def _lowercase( self ) -> str: if self.dataset_name is not None: pass elif self.train_file is None or self.validation_file is None: raise ValueError("""Need either a GLUE task, a training/validation file or a dataset name.""" ) else: UpperCAmelCase : Optional[int] = self.train_file.split(""".""" )[-1] assert train_extension in ["csv", "json"], "`train_file` should be a csv or a json file." UpperCAmelCase : List[str] = self.validation_file.split(""".""" )[-1] assert ( validation_extension == train_extension ), "`validation_file` should have the same extension (csv or json) as `train_file`." @dataclass class UpperCamelCase_ : lowercase = field( default=__magic_name__ , metadata={'help': 'Path to pretrained model or model identifier from huggingface.co/models'} ) lowercase = field( default=__magic_name__ , metadata={'help': 'Pretrained config name or path if not the same as model_name'} ) lowercase = field( default=__magic_name__ , metadata={'help': 'Pretrained tokenizer name or path if not the same as model_name'} ) lowercase = field( default=__magic_name__ , metadata={'help': 'Where do you want to store the pretrained models downloaded from huggingface.co'} , ) lowercase = field( default=__magic_name__ , metadata={'help': 'Whether to use one of the fast tokenizer (backed by the tokenizers library) or not.'} , ) lowercase = field( default='main' , metadata={'help': 'The specific model version to use (can be a branch name, tag name or commit id).'} , ) lowercase = field( default=__magic_name__ , metadata={ 'help': ( 'Will use the token generated when running `huggingface-cli login` (necessary to use this script ' 'with private models).' ) } , ) def __lowerCamelCase ( ) -> str: # See all possible arguments in src/transformers/training_args.py # or by passing the --help flag to this script. # We now keep distinct sets of args, for a cleaner separation of concerns. UpperCAmelCase : Optional[int] = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments) ) if len(sys.argv ) == 2 and sys.argv[1].endswith(""".json""" ): # If we pass only one argument to the script and it's the path to a json file, # let's parse it to get our arguments. UpperCAmelCase : List[Any] = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1] ) ) else: UpperCAmelCase : int = parser.parse_args_into_dataclasses() # Setup logging logging.basicConfig( format="""%(asctime)s - %(levelname)s - %(name)s - %(message)s""" , datefmt="""%m/%d/%Y %H:%M:%S""" , handlers=[logging.StreamHandler(sys.stdout )] , ) UpperCAmelCase : int = training_args.get_process_log_level() logger.setLevel(_lowercase ) datasets.utils.logging.set_verbosity(_lowercase ) transformers.utils.logging.set_verbosity(_lowercase ) transformers.utils.logging.enable_default_handler() transformers.utils.logging.enable_explicit_format() # Log on each process the small summary: logger.warning( F'''Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}''' + F'''distributed training: {bool(training_args.local_rank != -1 )}, 16-bits training: {training_args.fpaa}''' ) logger.info(F'''Training/evaluation parameters {training_args}''' ) # Detecting last checkpoint. UpperCAmelCase : Tuple = None if os.path.isdir(training_args.output_dir ) and training_args.do_train and not training_args.overwrite_output_dir: UpperCAmelCase : Optional[Any] = get_last_checkpoint(training_args.output_dir ) if last_checkpoint is None and len(os.listdir(training_args.output_dir ) ) > 0: raise ValueError( F'''Output directory ({training_args.output_dir}) already exists and is not empty. ''' """Use --overwrite_output_dir to overcome.""" ) elif last_checkpoint is not None and training_args.resume_from_checkpoint is None: logger.info( F'''Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change ''' """the `--output_dir` or add `--overwrite_output_dir` to train from scratch.""" ) # Set seed before initializing model. set_seed(training_args.seed ) # Get the datasets: you can either provide your own CSV/JSON training and evaluation files (see below) # or specify a GLUE benchmark task (the dataset will be downloaded automatically from the datasets Hub). # # For JSON files, this script will use the `question` column for the input question and `table` column for the corresponding table. # # If the CSVs/JSONs contain only one non-label column, the script does single sentence classification on this # single column. You can easily tweak this behavior (see below) # # In distributed training, the load_dataset function guarantee that only one local process can concurrently # download the dataset. if data_args.dataset_name is not None: # Downloading and loading a dataset from the hub. UpperCAmelCase : str = load_dataset( data_args.dataset_name , data_args.dataset_config_name , cache_dir=model_args.cache_dir ) else: # Loading a dataset from your local files. # CSV/JSON training and evaluation files are needed. UpperCAmelCase : Tuple = {"""train""": data_args.train_file, """validation""": data_args.validation_file} # Get the test dataset: you can provide your own CSV/JSON test file (see below) # when you use `do_predict` without specifying a GLUE benchmark task. if training_args.do_predict: if data_args.test_file is not None: UpperCAmelCase : Any = data_args.train_file.split(""".""" )[-1] UpperCAmelCase : Tuple = data_args.test_file.split(""".""" )[-1] assert ( test_extension == train_extension ), "`test_file` should have the same extension (csv or json) as `train_file`." UpperCAmelCase : int = data_args.test_file else: raise ValueError("""Need either a GLUE task or a test file for `do_predict`.""" ) for key in data_files.keys(): logger.info(F'''load a local file for {key}: {data_files[key]}''' ) if data_args.train_file.endswith(""".csv""" ): # Loading a dataset from local csv files UpperCAmelCase : str = load_dataset("""csv""" , data_files=_lowercase , cache_dir=model_args.cache_dir ) else: # Loading a dataset from local json files UpperCAmelCase : Optional[int] = load_dataset("""json""" , data_files=_lowercase , cache_dir=model_args.cache_dir ) # See more about loading any type of standard or custom dataset at # https://huggingface.co/docs/datasets/loading_datasets.html. # Labels UpperCAmelCase : Optional[int] = raw_datasets["""train"""].features["""label"""].names UpperCAmelCase : Union[str, Any] = len(_lowercase ) # Load pretrained model and tokenizer # # In distributed training, the .from_pretrained methods guarantee that only one local process can concurrently # download model & vocab. UpperCAmelCase : int = AutoConfig.from_pretrained( model_args.config_name if model_args.config_name else model_args.model_name_or_path , num_labels=_lowercase , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , ) # load tapex tokenizer UpperCAmelCase : int = TapexTokenizer.from_pretrained( model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path , cache_dir=model_args.cache_dir , use_fast=model_args.use_fast_tokenizer , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , add_prefix_space=_lowercase , ) UpperCAmelCase : str = BartForSequenceClassification.from_pretrained( model_args.model_name_or_path , from_tf=bool(""".ckpt""" in model_args.model_name_or_path ) , config=_lowercase , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , ) # Padding strategy if data_args.pad_to_max_length: UpperCAmelCase : List[Any] = """max_length""" else: # We will pad later, dynamically at batch creation, to the max sequence length in each batch UpperCAmelCase : Union[str, Any] = False # Some models have set the order of the labels to use, so let's make sure we do use it. UpperCAmelCase : Any = {"""Refused""": 0, """Entailed""": 1} UpperCAmelCase : str = {0: """Refused""", 1: """Entailed"""} if data_args.max_seq_length > tokenizer.model_max_length: logger.warning( F'''The max_seq_length passed ({data_args.max_seq_length}) is larger than the maximum length for the''' F'''model ({tokenizer.model_max_length}). Using max_seq_length={tokenizer.model_max_length}.''' ) UpperCAmelCase : Any = min(data_args.max_seq_length , tokenizer.model_max_length ) def preprocess_tabfact_function(_lowercase ): # Tokenize the texts def _convert_table_text_to_pandas(_lowercase ): UpperCAmelCase : Optional[int] = [_table_row.split("""#""" ) for _table_row in _table_text.strip("""\n""" ).split("""\n""" )] UpperCAmelCase : Optional[int] = pd.DataFrame.from_records(_table_content[1:] , columns=_table_content[0] ) return _table_pd UpperCAmelCase : Optional[Any] = examples["""statement"""] UpperCAmelCase : Any = list(map(_convert_table_text_to_pandas , examples["""table_text"""] ) ) UpperCAmelCase : int = tokenizer(_lowercase , _lowercase , padding=_lowercase , max_length=_lowercase , truncation=_lowercase ) UpperCAmelCase : Optional[Any] = examples["""label"""] return result with training_args.main_process_first(desc="""dataset map pre-processing""" ): UpperCAmelCase : Optional[Any] = raw_datasets.map( _lowercase , batched=_lowercase , load_from_cache_file=not data_args.overwrite_cache , desc="""Running tokenizer on dataset""" , ) if training_args.do_train: if "train" not in raw_datasets: raise ValueError("""--do_train requires a train dataset""" ) UpperCAmelCase : Any = raw_datasets["""train"""] if data_args.max_train_samples is not None: UpperCAmelCase : Any = train_dataset.select(range(data_args.max_train_samples ) ) if training_args.do_eval: if "validation" not in raw_datasets and "validation_matched" not in raw_datasets: raise ValueError("""--do_eval requires a validation dataset""" ) UpperCAmelCase : Union[str, Any] = raw_datasets["""validation"""] if data_args.max_eval_samples is not None: UpperCAmelCase : List[str] = eval_dataset.select(range(data_args.max_eval_samples ) ) if training_args.do_predict or data_args.test_file is not None: if "test" not in raw_datasets and "test_matched" not in raw_datasets: raise ValueError("""--do_predict requires a test dataset""" ) UpperCAmelCase : List[str] = raw_datasets["""test"""] if data_args.max_predict_samples is not None: UpperCAmelCase : Union[str, Any] = predict_dataset.select(range(data_args.max_predict_samples ) ) # Log a few random samples from the training set: if training_args.do_train: for index in random.sample(range(len(_lowercase ) ) , 3 ): logger.info(F'''Sample {index} of the training set: {train_dataset[index]}.''' ) # You can define your custom compute_metrics function. It takes an `EvalPrediction` object (a namedtuple with a # predictions and label_ids field) and has to return a dictionary string to float. def compute_metrics(_lowercase ): UpperCAmelCase : Optional[Any] = p.predictions[0] if isinstance(p.predictions , _lowercase ) else p.predictions UpperCAmelCase : Any = np.argmax(_lowercase , axis=1 ) return {"accuracy": (preds == p.label_ids).astype(np.floataa ).mean().item()} # Data collator will default to DataCollatorWithPadding, so we change it if we already did the padding. if data_args.pad_to_max_length: UpperCAmelCase : Tuple = default_data_collator elif training_args.fpaa: UpperCAmelCase : Tuple = DataCollatorWithPadding(_lowercase , pad_to_multiple_of=8 ) else: UpperCAmelCase : Dict = None # Initialize our Trainer UpperCAmelCase : int = Trainer( model=_lowercase , args=_lowercase , train_dataset=train_dataset if training_args.do_train else None , eval_dataset=eval_dataset if training_args.do_eval else None , compute_metrics=_lowercase , tokenizer=_lowercase , data_collator=_lowercase , ) # Training if training_args.do_train: UpperCAmelCase : Optional[int] = None if training_args.resume_from_checkpoint is not None: UpperCAmelCase : Optional[int] = training_args.resume_from_checkpoint elif last_checkpoint is not None: UpperCAmelCase : Dict = last_checkpoint UpperCAmelCase : str = trainer.train(resume_from_checkpoint=_lowercase ) UpperCAmelCase : List[Any] = train_result.metrics UpperCAmelCase : Optional[Any] = ( data_args.max_train_samples if data_args.max_train_samples is not None else len(_lowercase ) ) UpperCAmelCase : Dict = min(_lowercase , len(_lowercase ) ) trainer.save_model() # Saves the tokenizer too for easy upload trainer.log_metrics("""train""" , _lowercase ) trainer.save_metrics("""train""" , _lowercase ) trainer.save_state() # Evaluation if training_args.do_eval: logger.info("""*** Evaluate ***""" ) UpperCAmelCase : Union[str, Any] = trainer.evaluate(eval_dataset=_lowercase ) UpperCAmelCase : Any = data_args.max_eval_samples if data_args.max_eval_samples is not None else len(_lowercase ) UpperCAmelCase : Any = min(_lowercase , len(_lowercase ) ) trainer.log_metrics("""eval""" , _lowercase ) trainer.save_metrics("""eval""" , _lowercase ) if training_args.do_predict: logger.info("""*** Predict ***""" ) # Removing the `label` columns because it contains -1 and Trainer won't like that. UpperCAmelCase : Tuple = predict_dataset.remove_columns("""label""" ) UpperCAmelCase : List[str] = trainer.predict(_lowercase , metric_key_prefix="""predict""" ).predictions UpperCAmelCase : Dict = np.argmax(_lowercase , axis=1 ) UpperCAmelCase : Any = os.path.join(training_args.output_dir , """predict_results_tabfact.txt""" ) if trainer.is_world_process_zero(): with open(_lowercase , """w""" ) as writer: logger.info("""***** Predict Results *****""" ) writer.write("""index\tprediction\n""" ) for index, item in enumerate(_lowercase ): UpperCAmelCase : Tuple = label_list[item] writer.write(F'''{index}\t{item}\n''' ) UpperCAmelCase : Any = {"""finetuned_from""": model_args.model_name_or_path, """tasks""": """text-classification"""} if training_args.push_to_hub: trainer.push_to_hub(**_lowercase ) else: trainer.create_model_card(**_lowercase ) def __lowerCamelCase ( _lowercase ) -> str: # For xla_spawn (TPUs) main() if __name__ == "__main__": main()

'''simple docstring''' import argparse from pathlib import Path import torch from transformers import OPTConfig, OPTModel from transformers.utils import logging logging.set_verbosity_info() a : List[Any] = logging.get_logger(__name__) def __lowerCamelCase ( _lowercase ) -> List[Any]: UpperCAmelCase : Dict = torch.load(_lowercase , map_location="""cpu""" ) if "model" in sd.keys(): UpperCAmelCase : Any = torch.load(_lowercase , map_location="""cpu""" )["""model"""] # pop unnecessary weights UpperCAmelCase : Union[str, Any] = [ """decoder.version""", """decoder.output_projection.weight""", ] for key in keys_to_delete: if key in sd: sd.pop(_lowercase ) UpperCAmelCase : Tuple = { """decoder.project_in_dim.weight""": """decoder.project_in.weight""", """decoder.project_out_dim.weight""": """decoder.project_out.weight""", """decoder.layer_norm.weight""": """decoder.final_layer_norm.weight""", """decoder.layer_norm.bias""": """decoder.final_layer_norm.bias""", } for old_key, new_key in keys_to_rename.items(): if old_key in sd: UpperCAmelCase : List[Any] = sd.pop(_lowercase ) UpperCAmelCase : Tuple = list(sd.keys() ) for key in keys: if ".qkv_proj." in key: UpperCAmelCase : List[str] = sd[key] # We split QKV in separate Q,K,V UpperCAmelCase : Dict = key.replace(""".qkv_proj.""" , """.q_proj.""" ) UpperCAmelCase : Tuple = key.replace(""".qkv_proj.""" , """.k_proj.""" ) UpperCAmelCase : int = key.replace(""".qkv_proj.""" , """.v_proj.""" ) UpperCAmelCase : Dict = value.shape[0] assert depth % 3 == 0 # `SequeuceParallelTransformerBlock` has QKV weight is separated in K,V,Q despite the naming: # https://cs.github.com/facebookresearch/metaseq/blob/51871bd73cd04c038f239ea2a26db1d7f6b37927/metaseq/modules/sequence_parallel_transformer_layer.py#L97 UpperCAmelCase , UpperCAmelCase , UpperCAmelCase : Dict = torch.split(_lowercase , depth // 3 , dim=0 ) UpperCAmelCase : Tuple = q UpperCAmelCase : Tuple = k UpperCAmelCase : Any = v del sd[key] return sd @torch.no_grad() def __lowerCamelCase ( _lowercase , _lowercase , _lowercase=None ) -> Optional[Any]: UpperCAmelCase : Tuple = load_checkpoint(_lowercase ) if config is not None: UpperCAmelCase : Dict = OPTConfig.from_pretrained(_lowercase ) else: UpperCAmelCase : int = OPTConfig() UpperCAmelCase : List[Any] = OPTModel(_lowercase ).half().eval() model.load_state_dict(_lowercase ) # Check results Path(_lowercase ).mkdir(exist_ok=_lowercase ) model.save_pretrained(_lowercase ) if __name__ == "__main__": a : Any = argparse.ArgumentParser() # Required parameters parser.add_argument( """--fairseq_path""", type=str, help=( """path to fairseq checkpoint in correct format. You can find all checkpoints in the correct format here:""" """ https://huggingface.co/models?other=opt_metasq""" ), ) parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""") parser.add_argument("""--hf_config""", default=None, type=str, help="""Define HF config.""") a : Union[str, Any] = parser.parse_args() convert_opt_checkpoint(args.fairseq_path, args.pytorch_dump_folder_path, config=args.hf_config)

"""simple docstring""" import os def _snake_case ( lowercase__ : str = "matrix.txt" ) -> int: '''simple docstring''' with open(os.path.join(os.path.dirname(lowercase__ ) , lowercase__ ) ) as in_file: lowerCAmelCase_ :str = in_file.read() lowerCAmelCase_ :Tuple = [[int(lowercase__ ) for cell in row.split(""",""" )] for row in data.strip().splitlines()] lowerCAmelCase_ :Tuple = [[0 for cell in row] for row in grid] lowerCAmelCase_ :str = len(grid[0] ) lowerCAmelCase_ :Union[str, Any] = [[0 for i in range(lowercase__ )] for j in range(lowercase__ )] lowerCAmelCase_ :Optional[Any] = grid[0][0] for i in range(1 , lowercase__ ): lowerCAmelCase_ :Optional[int] = grid[0][i] + dp[0][i - 1] for i in range(1 , lowercase__ ): lowerCAmelCase_ :str = grid[i][0] + dp[i - 1][0] for i in range(1 , lowercase__ ): for j in range(1 , lowercase__ ): lowerCAmelCase_ :Dict = grid[i][j] + min(dp[i - 1][j] , dp[i][j - 1] ) return dp[-1][-1] if __name__ == "__main__": print(F"""{solution() = }""")

"""simple docstring""" from typing import Optional, Union import numpy as np from ...image_processing_utils import BaseImageProcessor, BatchFeature from ...image_transforms import get_image_size, pad, rescale, to_channel_dimension_format from ...image_utils import ChannelDimension, ImageInput, make_list_of_images, to_numpy_array, valid_images from ...utils import TensorType, logging _lowercase : Tuple = logging.get_logger(__name__) class __SCREAMING_SNAKE_CASE ( lowerCAmelCase_ ): '''simple docstring''' _a = ['pixel_values'] def __init__( self : Optional[Any], lowerCamelCase : bool = True, lowerCamelCase : Union[int, float] = 1 / 255, lowerCamelCase : bool = True, lowerCamelCase : int = 8, **lowerCamelCase : Tuple, )-> None: super().__init__(**lowerCamelCase ) lowerCamelCase__ : int =do_rescale lowerCamelCase__ : Dict =rescale_factor lowerCamelCase__ : Union[str, Any] =do_pad lowerCamelCase__ : Union[str, Any] =pad_size def snake_case ( self : int, lowerCamelCase : np.ndarray, lowerCamelCase : float, lowerCamelCase : Optional[Union[str, ChannelDimension]] = None, **lowerCamelCase : int )-> np.ndarray: return rescale(lowerCamelCase, scale=lowerCamelCase, data_format=lowerCamelCase, **lowerCamelCase ) def snake_case ( self : Optional[Any], lowerCamelCase : np.ndarray, lowerCamelCase : int, lowerCamelCase : Optional[Union[str, ChannelDimension]] = None )-> List[Any]: lowerCamelCase__ , lowerCamelCase__ : Optional[int] =get_image_size(lowerCamelCase ) lowerCamelCase__ : List[str] =(old_height // size + 1) * size - old_height lowerCamelCase__ : List[str] =(old_width // size + 1) * size - old_width return pad(lowerCamelCase, ((0, pad_height), (0, pad_width)), mode='''symmetric''', data_format=lowerCamelCase ) def snake_case ( self : List[Any], lowerCamelCase : ImageInput, lowerCamelCase : Optional[bool] = None, lowerCamelCase : Optional[float] = None, lowerCamelCase : Optional[bool] = None, lowerCamelCase : Optional[int] = None, lowerCamelCase : Optional[Union[str, TensorType]] = None, lowerCamelCase : Union[str, ChannelDimension] = ChannelDimension.FIRST, **lowerCamelCase : Union[str, Any], )-> Dict: lowerCamelCase__ : List[str] =do_rescale if do_rescale is not None else self.do_rescale lowerCamelCase__ : Tuple =rescale_factor if rescale_factor is not None else self.rescale_factor lowerCamelCase__ : str =do_pad if do_pad is not None else self.do_pad lowerCamelCase__ : int =pad_size if pad_size is not None else self.pad_size lowerCamelCase__ : Optional[int] =make_list_of_images(lowerCamelCase ) if not valid_images(lowerCamelCase ): raise ValueError( '''Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, ''' '''torch.Tensor, tf.Tensor or jax.ndarray.''' ) if do_rescale and rescale_factor is None: raise ValueError('''Rescale factor must be specified if do_rescale is True.''' ) # All transformations expect numpy arrays. lowerCamelCase__ : Tuple =[to_numpy_array(lowerCamelCase ) for image in images] if do_rescale: lowerCamelCase__ : Tuple =[self.rescale(image=lowerCamelCase, scale=lowerCamelCase ) for image in images] if do_pad: lowerCamelCase__ : Tuple =[self.pad(lowerCamelCase, size=lowerCamelCase ) for image in images] lowerCamelCase__ : int =[to_channel_dimension_format(lowerCamelCase, lowerCamelCase ) for image in images] lowerCamelCase__ : Dict ={'''pixel_values''': images} return BatchFeature(data=lowerCamelCase, tensor_type=lowerCamelCase )

"""simple docstring""" from dataclasses import dataclass from typing import List, Optional, Union import numpy as np import torch from ...utils import BaseOutput, OptionalDependencyNotAvailable, is_torch_available, is_transformers_available @dataclass class lowerCamelCase ( _UpperCAmelCase ): lowercase : Union[List[np.ndarray], torch.FloatTensor] try: if not (is_transformers_available() and is_torch_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ...utils.dummy_torch_and_transformers_objects import * # noqa F403 else: from .pipeline_text_to_video_synth import TextToVideoSDPipeline from .pipeline_text_to_video_synth_imgaimg import VideoToVideoSDPipeline # noqa: F401 from .pipeline_text_to_video_zero import TextToVideoZeroPipeline

"""simple docstring""" import argparse import os import evaluate import torch from datasets import load_dataset from torch.optim import AdamW from torch.utils.data import DataLoader from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed from accelerate import Accelerator, DistributedType from accelerate.local_sgd import LocalSGD ######################################################################## # This is a fully working simple example to use Accelerate # with LocalSGD, which is a method to synchronize model # parameters every K batches. It is different, but complementary # to gradient accumulation. # # This example trains a Bert base model on GLUE MRPC # in any of the following settings (with the same script): # - single CPU or single GPU # - multi GPUS (using PyTorch distributed mode) # - (multi) TPUs # - fp16 (mixed-precision) or fp32 (normal precision) # # To run it in each of these various modes, follow the instructions # in the readme for examples: # https://github.com/huggingface/accelerate/tree/main/examples # ######################################################################## __A : Optional[Any] = 16 __A : str = 32 def A_ ( snake_case_ : Accelerator ,snake_case_ : int = 1_6 ): '''simple docstring''' UpperCamelCase : Tuple = AutoTokenizer.from_pretrained("""bert-base-cased""" ) UpperCamelCase : Optional[int] = load_dataset("""glue""" ,"""mrpc""" ) def tokenize_function(snake_case_ : List[Any] ): # max_length=None => use the model max length (it's actually the default) UpperCamelCase : Union[str, Any] = tokenizer(examples["""sentence1"""] ,examples["""sentence2"""] ,truncation=snake_case_ ,max_length=snake_case_ ) return outputs # Apply the method we just defined to all the examples in all the splits of the dataset # starting with the main process first: with accelerator.main_process_first(): UpperCamelCase : Optional[Any] = datasets.map( snake_case_ ,batched=snake_case_ ,remove_columns=["""idx""", """sentence1""", """sentence2"""] ,) # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the # transformers library UpperCamelCase : str = tokenized_datasets.rename_column("""label""" ,"""labels""" ) def collate_fn(snake_case_ : Any ): # On TPU it's best to pad everything to the same length or training will be very slow. UpperCamelCase : Union[str, Any] = 1_2_8 if accelerator.distributed_type == DistributedType.TPU else None # When using mixed precision we want round multiples of 8/16 if accelerator.mixed_precision == "fp8": UpperCamelCase : Optional[Any] = 1_6 elif accelerator.mixed_precision != "no": UpperCamelCase : Any = 8 else: UpperCamelCase : Optional[Any] = None return tokenizer.pad( snake_case_ ,padding="""longest""" ,max_length=snake_case_ ,pad_to_multiple_of=snake_case_ ,return_tensors="""pt""" ,) # Instantiate dataloaders. UpperCamelCase : str = DataLoader( tokenized_datasets["""train"""] ,shuffle=snake_case_ ,collate_fn=snake_case_ ,batch_size=snake_case_ ) UpperCamelCase : Dict = DataLoader( tokenized_datasets["""validation"""] ,shuffle=snake_case_ ,collate_fn=snake_case_ ,batch_size=snake_case_ ) return train_dataloader, eval_dataloader # For testing only if os.environ.get('''TESTING_MOCKED_DATALOADERS''', None) == "1": from accelerate.test_utils.training import mocked_dataloaders __A : int = mocked_dataloaders # noqa: F811 def A_ ( snake_case_ : Tuple ,snake_case_ : Dict ): '''simple docstring''' # For testing only if os.environ.get("""TESTING_MOCKED_DATALOADERS""" ,snake_case_ ) == "1": UpperCamelCase : Union[str, Any] = 2 # New Code # UpperCamelCase : Dict = int(args.gradient_accumulation_steps ) UpperCamelCase : List[Any] = int(args.local_sgd_steps ) # Initialize accelerator UpperCamelCase : str = Accelerator( cpu=args.cpu ,mixed_precision=args.mixed_precision ,gradient_accumulation_steps=snake_case_ ) if accelerator.distributed_type not in [DistributedType.NO, DistributedType.MULTI_CPU, DistributedType.MULTI_GPU]: raise NotImplementedError("""LocalSGD is supported only for CPUs and GPUs (no DeepSpeed or MegatronLM)""" ) # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs UpperCamelCase : Union[str, Any] = config["""lr"""] UpperCamelCase : int = int(config["""num_epochs"""] ) UpperCamelCase : int = int(config["""seed"""] ) UpperCamelCase : List[Any] = int(config["""batch_size"""] ) UpperCamelCase : Optional[int] = evaluate.load("""glue""" ,"""mrpc""" ) set_seed(snake_case_ ) UpperCamelCase , UpperCamelCase : Dict = get_dataloaders(snake_case_ ,snake_case_ ) # Instantiate the model (we build the model here so that the seed also control new weights initialization) UpperCamelCase : Optional[int] = AutoModelForSequenceClassification.from_pretrained("""bert-base-cased""" ,return_dict=snake_case_ ) # We could avoid this line since the accelerator is set with `device_placement=True` (default value). # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that). UpperCamelCase : Tuple = model.to(accelerator.device ) # Instantiate optimizer UpperCamelCase : List[Any] = AdamW(params=model.parameters() ,lr=snake_case_ ) # Instantiate scheduler UpperCamelCase : str = get_linear_schedule_with_warmup( optimizer=snake_case_ ,num_warmup_steps=1_0_0 ,num_training_steps=(len(snake_case_ ) * num_epochs) ,) # 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. UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase : Any = accelerator.prepare( snake_case_ ,snake_case_ ,snake_case_ ,snake_case_ ,snake_case_ ) # Now we train the model for epoch in range(snake_case_ ): model.train() with LocalSGD( accelerator=snake_case_ ,model=snake_case_ ,local_sgd_steps=snake_case_ ,enabled=local_sgd_steps is not None ) as local_sgd: for step, batch in enumerate(snake_case_ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) # New code # # We use the new `accumulate` context manager to perform gradient accumulation # We also currently do not support TPUs nor advise it as bugs were found on the XLA side when running our tests. with accelerator.accumulate(snake_case_ ): UpperCamelCase : Optional[Any] = model(**snake_case_ ) UpperCamelCase : Optional[int] = output.loss accelerator.backward(snake_case_ ) optimizer.step() lr_scheduler.step() optimizer.zero_grad() # LocalSGD-specific line local_sgd.step() model.eval() for step, batch in enumerate(snake_case_ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) with torch.no_grad(): UpperCamelCase : Any = model(**snake_case_ ) UpperCamelCase : Tuple = outputs.logits.argmax(dim=-1 ) UpperCamelCase , UpperCamelCase : int = accelerator.gather_for_metrics((predictions, batch["""labels"""]) ) metric.add_batch( predictions=snake_case_ ,references=snake_case_ ,) UpperCamelCase : str = metric.compute() # Use accelerator.print to print only on the main process. accelerator.print(f'epoch {epoch}:' ,snake_case_ ) def A_ ( ): '''simple docstring''' UpperCamelCase : str = argparse.ArgumentParser(description="""Simple example of training script.""" ) parser.add_argument( """--mixed_precision""" ,type=snake_case_ ,default=snake_case_ ,choices=["""no""", """fp16""", """bf16""", """fp8"""] ,help="""Whether to use mixed precision. Choose""" """between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.""" """and an Nvidia Ampere GPU.""" ,) # New Code # parser.add_argument( """--gradient_accumulation_steps""" ,type=snake_case_ ,default=1 ,help="""The number of minibatches to be ran before gradients are accumulated.""" ,) parser.add_argument( """--local_sgd_steps""" ,type=snake_case_ ,default=8 ,help="""Number of local SGD steps or None to disable local SGD""" ) parser.add_argument("""--cpu""" ,action="""store_true""" ,help="""If passed, will train on the CPU.""" ) UpperCamelCase : Dict = parser.parse_args() UpperCamelCase : List[Any] = {"""lr""": 2e-5, """num_epochs""": 3, """seed""": 4_2, """batch_size""": 1_6} training_function(snake_case_ ,snake_case_ ) if __name__ == "__main__": main()

'''simple docstring''' import argparse from collections import OrderedDict from pathlib import Path import torch from transformers import ( VisualBertConfig, VisualBertForMultipleChoice, VisualBertForPreTraining, VisualBertForQuestionAnswering, VisualBertForVisualReasoning, ) from transformers.utils import logging logging.set_verbosity_info() lowercase_ = logging.get_logger(__name__) lowercase_ = [ ("""bert.bert""", """visual_bert"""), ("""bert.cls""", """cls"""), ("""bert.classifier""", """cls"""), ("""token_type_embeddings_visual""", """visual_token_type_embeddings"""), ("""position_embeddings_visual""", """visual_position_embeddings"""), ("""projection""", """visual_projection"""), ] lowercase_ = [ """nlvr2_coco_pre_trained.th""", """nlvr2_fine_tuned.th""", """nlvr2_pre_trained.th""", """vcr_coco_pre_train.th""", """vcr_fine_tune.th""", """vcr_pre_train.th""", """vqa_coco_pre_trained.th""", """vqa_fine_tuned.th""", """vqa_pre_trained.th""", ] def lowerCamelCase ( __lowerCamelCase : Any ) ->List[Any]: _SCREAMING_SNAKE_CASE = torch.load(__lowerCamelCase , map_location="""cpu""" ) return sd def lowerCamelCase ( __lowerCamelCase : Optional[int] , __lowerCamelCase : List[str] , __lowerCamelCase : Optional[Any]=rename_keys_prefix ) ->List[str]: _SCREAMING_SNAKE_CASE = OrderedDict() _SCREAMING_SNAKE_CASE = torch.arange(config.max_position_embeddings ).expand((1, -1) ) # detector_d = OrderedDict() for key in d: if "detector" in key: # detector_d[key.replace('detector.','')] = d[key] continue _SCREAMING_SNAKE_CASE = key for name_pair in rename_keys_prefix: _SCREAMING_SNAKE_CASE = new_key.replace(name_pair[0] , name_pair[1] ) _SCREAMING_SNAKE_CASE = d[key] if key == "bert.cls.predictions.decoder.weight": # Old bert code didn't have `decoder.bias`, but was added separately _SCREAMING_SNAKE_CASE = new_d["""cls.predictions.bias"""] return new_d @torch.no_grad() def lowerCamelCase ( __lowerCamelCase : Tuple , __lowerCamelCase : Union[str, Any] ) ->Union[str, Any]: assert ( checkpoint_path.split("""/""" )[-1] in ACCEPTABLE_CHECKPOINTS ), F'The checkpoint provided must be in {ACCEPTABLE_CHECKPOINTS}.' # Get Config if "pre" in checkpoint_path: _SCREAMING_SNAKE_CASE = """pretraining""" if "vcr" in checkpoint_path: _SCREAMING_SNAKE_CASE = {"""visual_embedding_dim""": 512} elif "vqa_advanced" in checkpoint_path: _SCREAMING_SNAKE_CASE = {"""visual_embedding_dim""": 2048} elif "vqa" in checkpoint_path: _SCREAMING_SNAKE_CASE = {"""visual_embedding_dim""": 2048} elif "nlvr" in checkpoint_path: _SCREAMING_SNAKE_CASE = {"""visual_embedding_dim""": 1024} else: raise NotImplementedError(F'No implementation found for `{checkpoint_path}`.' ) else: if "vcr" in checkpoint_path: _SCREAMING_SNAKE_CASE = {"""visual_embedding_dim""": 512} _SCREAMING_SNAKE_CASE = """multichoice""" elif "vqa_advanced" in checkpoint_path: _SCREAMING_SNAKE_CASE = {"""visual_embedding_dim""": 2048} _SCREAMING_SNAKE_CASE = """vqa_advanced""" elif "vqa" in checkpoint_path: _SCREAMING_SNAKE_CASE = {"""visual_embedding_dim""": 2048, """num_labels""": 3129} _SCREAMING_SNAKE_CASE = """vqa""" elif "nlvr" in checkpoint_path: _SCREAMING_SNAKE_CASE = { """visual_embedding_dim""": 1024, """num_labels""": 2, } _SCREAMING_SNAKE_CASE = """nlvr""" _SCREAMING_SNAKE_CASE = VisualBertConfig(**__lowerCamelCase ) # Load State Dict _SCREAMING_SNAKE_CASE = load_state_dict(__lowerCamelCase ) _SCREAMING_SNAKE_CASE = get_new_dict(__lowerCamelCase , __lowerCamelCase ) if model_type == "pretraining": _SCREAMING_SNAKE_CASE = VisualBertForPreTraining(__lowerCamelCase ) elif model_type == "vqa": _SCREAMING_SNAKE_CASE = VisualBertForQuestionAnswering(__lowerCamelCase ) elif model_type == "nlvr": _SCREAMING_SNAKE_CASE = VisualBertForVisualReasoning(__lowerCamelCase ) elif model_type == "multichoice": _SCREAMING_SNAKE_CASE = VisualBertForMultipleChoice(__lowerCamelCase ) model.load_state_dict(__lowerCamelCase ) # Save Checkpoints Path(__lowerCamelCase ).mkdir(exist_ok=__lowerCamelCase ) model.save_pretrained(__lowerCamelCase ) if __name__ == "__main__": lowercase_ = argparse.ArgumentParser() # Required parameters parser.add_argument("""orig_checkpoint_path""", type=str, help="""A path to .th on local filesystem.""") parser.add_argument("""pytorch_dump_folder_path""", type=str, help="""Path to the output PyTorch model.""") lowercase_ = parser.parse_args() convert_visual_bert_checkpoint(args.orig_checkpoint_path, args.pytorch_dump_folder_path)

'''simple docstring''' import os import sys import warnings from dataclasses import dataclass, field from io import BytesIO from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union import numpy as np import pyarrow as pa from .. import config from ..download.streaming_download_manager import xopen from ..table import array_cast from ..utils.file_utils import is_local_path from ..utils.py_utils import first_non_null_value, no_op_if_value_is_null, string_to_dict if TYPE_CHECKING: import PIL.Image from .features import FeatureType lowercase_ = None lowercase_ = """<""" if sys.byteorder == """little""" else """>""" # Origin: https://github.com/python-pillow/Pillow/blob/698951e19e19972aeed56df686868f1329981c12/src/PIL/Image.py#L3126 minus "|i1" which values are not preserved correctly when saving and loading an image lowercase_ = [ np.dtype("""|b1"""), np.dtype("""|u1"""), np.dtype("""<u2"""), np.dtype(""">u2"""), np.dtype("""<i2"""), np.dtype(""">i2"""), np.dtype("""<u4"""), np.dtype(""">u4"""), np.dtype("""<i4"""), np.dtype(""">i4"""), np.dtype("""<f4"""), np.dtype(""">f4"""), np.dtype("""<f8"""), np.dtype(""">f8"""), ] @dataclass class a_ : '''simple docstring''' UpperCamelCase = True UpperCamelCase = None # Automatically constructed UpperCamelCase = "PIL.Image.Image" UpperCamelCase = pa.struct({'''bytes''': pa.binary(), '''path''': pa.string()} ) UpperCamelCase = field(default='''Image''' , init=snake_case_ , repr=snake_case_ ) def __call__( self ) -> Tuple: return self.pa_type def snake_case_( self , A ) -> dict: if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) if isinstance(A , A ): _SCREAMING_SNAKE_CASE = np.array(A ) if isinstance(A , A ): return {"path": value, "bytes": None} elif isinstance(A , A ): return {"path": None, "bytes": value} elif isinstance(A , np.ndarray ): # convert the image array to PNG/TIFF bytes return encode_np_array(A ) elif isinstance(A , PIL.Image.Image ): # convert the PIL image to bytes (default format is PNG/TIFF) return encode_pil_image(A ) elif value.get("""path""" ) is not None and os.path.isfile(value["""path"""] ): # we set "bytes": None to not duplicate the data if they're already available locally return {"bytes": None, "path": value.get("""path""" )} elif value.get("""bytes""" ) is not None or value.get("""path""" ) is not None: # store the image bytes, and path is used to infer the image format using the file extension return {"bytes": value.get("""bytes""" ), "path": value.get("""path""" )} else: raise ValueError( f'An image sample should have one of \'path\' or \'bytes\' but they are missing or None in {value}.' ) def snake_case_( self , A , A=None ) -> "PIL.Image.Image": if not self.decode: raise RuntimeError("""Decoding is disabled for this feature. Please use Image(decode=True) instead.""" ) if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support decoding images, please install 'Pillow'.""" ) if token_per_repo_id is None: _SCREAMING_SNAKE_CASE = {} _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE = value["""path"""], value["""bytes"""] if bytes_ is None: if path is None: raise ValueError(f'An image should have one of \'path\' or \'bytes\' but both are None in {value}.' ) else: if is_local_path(A ): _SCREAMING_SNAKE_CASE = PIL.Image.open(A ) else: _SCREAMING_SNAKE_CASE = path.split("""::""" )[-1] try: _SCREAMING_SNAKE_CASE = string_to_dict(A , config.HUB_DATASETS_URL )["""repo_id"""] _SCREAMING_SNAKE_CASE = token_per_repo_id.get(A ) except ValueError: _SCREAMING_SNAKE_CASE = None with xopen(A , """rb""" , use_auth_token=A ) as f: _SCREAMING_SNAKE_CASE = BytesIO(f.read() ) _SCREAMING_SNAKE_CASE = PIL.Image.open(bytes_ ) else: _SCREAMING_SNAKE_CASE = PIL.Image.open(BytesIO(bytes_ ) ) image.load() # to avoid "Too many open files" errors return image def snake_case_( self ) -> Union["FeatureType", Dict[str, "FeatureType"]]: from .features import Value return ( self if self.decode else { "bytes": Value("""binary""" ), "path": Value("""string""" ), } ) def snake_case_( self , A ) -> pa.StructArray: if pa.types.is_string(storage.type ): _SCREAMING_SNAKE_CASE = pa.array([None] * len(A ) , type=pa.binary() ) _SCREAMING_SNAKE_CASE = pa.StructArray.from_arrays([bytes_array, storage] , ["""bytes""", """path"""] , mask=storage.is_null() ) elif pa.types.is_binary(storage.type ): _SCREAMING_SNAKE_CASE = pa.array([None] * len(A ) , type=pa.string() ) _SCREAMING_SNAKE_CASE = pa.StructArray.from_arrays([storage, path_array] , ["""bytes""", """path"""] , mask=storage.is_null() ) elif pa.types.is_struct(storage.type ): if storage.type.get_field_index("""bytes""" ) >= 0: _SCREAMING_SNAKE_CASE = storage.field("""bytes""" ) else: _SCREAMING_SNAKE_CASE = pa.array([None] * len(A ) , type=pa.binary() ) if storage.type.get_field_index("""path""" ) >= 0: _SCREAMING_SNAKE_CASE = storage.field("""path""" ) else: _SCREAMING_SNAKE_CASE = pa.array([None] * len(A ) , type=pa.string() ) _SCREAMING_SNAKE_CASE = pa.StructArray.from_arrays([bytes_array, path_array] , ["""bytes""", """path"""] , mask=storage.is_null() ) elif pa.types.is_list(storage.type ): _SCREAMING_SNAKE_CASE = pa.array( [encode_np_array(np.array(A ) )["""bytes"""] if arr is not None else None for arr in storage.to_pylist()] , type=pa.binary() , ) _SCREAMING_SNAKE_CASE = pa.array([None] * len(A ) , type=pa.string() ) _SCREAMING_SNAKE_CASE = pa.StructArray.from_arrays( [bytes_array, path_array] , ["""bytes""", """path"""] , mask=bytes_array.is_null() ) return array_cast(A , self.pa_type ) def snake_case_( self , A ) -> pa.StructArray: @no_op_if_value_is_null def path_to_bytes(A ): with xopen(A , """rb""" ) as f: _SCREAMING_SNAKE_CASE = f.read() return bytes_ _SCREAMING_SNAKE_CASE = pa.array( [ (path_to_bytes(x["""path"""] ) if x["""bytes"""] is None else x["""bytes"""]) if x is not None else None for x in storage.to_pylist() ] , type=pa.binary() , ) _SCREAMING_SNAKE_CASE = pa.array( [os.path.basename(A ) if path is not None else None for path in storage.field("""path""" ).to_pylist()] , type=pa.string() , ) _SCREAMING_SNAKE_CASE = pa.StructArray.from_arrays([bytes_array, path_array] , ["""bytes""", """path"""] , mask=bytes_array.is_null() ) return array_cast(A , self.pa_type ) def lowerCamelCase ( ) ->List[str]: if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) global _IMAGE_COMPRESSION_FORMATS if _IMAGE_COMPRESSION_FORMATS is None: PIL.Image.init() _SCREAMING_SNAKE_CASE = list(set(PIL.Image.OPEN.keys() ) & set(PIL.Image.SAVE.keys() ) ) return _IMAGE_COMPRESSION_FORMATS def lowerCamelCase ( __lowerCamelCase : "PIL.Image.Image" ) ->bytes: _SCREAMING_SNAKE_CASE = BytesIO() if image.format in list_image_compression_formats(): _SCREAMING_SNAKE_CASE = image.format else: _SCREAMING_SNAKE_CASE = """PNG""" if image.mode in ["""1""", """L""", """LA""", """RGB""", """RGBA"""] else """TIFF""" image.save(__lowerCamelCase , format=__lowerCamelCase ) return buffer.getvalue() def lowerCamelCase ( __lowerCamelCase : "PIL.Image.Image" ) ->dict: if hasattr(__lowerCamelCase , """filename""" ) and image.filename != "": return {"path": image.filename, "bytes": None} else: return {"path": None, "bytes": image_to_bytes(__lowerCamelCase )} def lowerCamelCase ( __lowerCamelCase : np.ndarray ) ->dict: if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) _SCREAMING_SNAKE_CASE = array.dtype _SCREAMING_SNAKE_CASE = dtype.byteorder if dtype.byteorder != """=""" else _NATIVE_BYTEORDER _SCREAMING_SNAKE_CASE = dtype.kind _SCREAMING_SNAKE_CASE = dtype.itemsize _SCREAMING_SNAKE_CASE = None # Multi-channel array case (only np.dtype("|u1") is allowed) if array.shape[2:]: _SCREAMING_SNAKE_CASE = np.dtype("""|u1""" ) if dtype_kind not in ["u", "i"]: raise TypeError( F'Unsupported array dtype {dtype} for image encoding. Only {dest_dtype} is supported for multi-channel arrays.' ) if dtype is not dest_dtype: warnings.warn(F'Downcasting array dtype {dtype} to {dest_dtype} to be compatible with \'Pillow\'' ) # Exact match elif dtype in _VALID_IMAGE_ARRAY_DTPYES: _SCREAMING_SNAKE_CASE = dtype else: # Downcast the type within the kind (np.can_cast(from_type, to_type, casting="same_kind") doesn't behave as expected, so do it manually) while dtype_itemsize >= 1: _SCREAMING_SNAKE_CASE = dtype_byteorder + dtype_kind + str(__lowerCamelCase ) _SCREAMING_SNAKE_CASE = np.dtype(__lowerCamelCase ) if dest_dtype in _VALID_IMAGE_ARRAY_DTPYES: warnings.warn(F'Downcasting array dtype {dtype} to {dest_dtype} to be compatible with \'Pillow\'' ) break else: dtype_itemsize //= 2 if dest_dtype is None: raise TypeError( F'Cannot convert dtype {dtype} to a valid image dtype. Valid image dtypes: {_VALID_IMAGE_ARRAY_DTPYES}' ) _SCREAMING_SNAKE_CASE = PIL.Image.fromarray(array.astype(__lowerCamelCase ) ) return {"path": None, "bytes": image_to_bytes(__lowerCamelCase )} def lowerCamelCase ( __lowerCamelCase : Union[List[str], List[dict], List[np.ndarray], List["PIL.Image.Image"]] ) ->List[dict]: if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) if objs: _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE = first_non_null_value(__lowerCamelCase ) if isinstance(__lowerCamelCase , __lowerCamelCase ): return [{"path": obj, "bytes": None} if obj is not None else None for obj in objs] if isinstance(__lowerCamelCase , np.ndarray ): _SCREAMING_SNAKE_CASE = no_op_if_value_is_null(__lowerCamelCase ) return [obj_to_image_dict_func(__lowerCamelCase ) for obj in objs] elif isinstance(__lowerCamelCase , PIL.Image.Image ): _SCREAMING_SNAKE_CASE = no_op_if_value_is_null(__lowerCamelCase ) return [obj_to_image_dict_func(__lowerCamelCase ) for obj in objs] else: return objs else: return objs

import gc import unittest import numpy as np import torch from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer from diffusers import AutoencoderKL, DDIMScheduler, LDMTextToImagePipeline, UNetaDConditionModel from diffusers.utils.testing_utils import ( enable_full_determinism, load_numpy, nightly, require_torch_gpu, slow, torch_device, ) from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS from ..test_pipelines_common import PipelineTesterMixin enable_full_determinism() class __SCREAMING_SNAKE_CASE ( _a , unittest.TestCase ): snake_case : Optional[int] = LDMTextToImagePipeline snake_case : str = TEXT_TO_IMAGE_PARAMS - { """negative_prompt""", """negative_prompt_embeds""", """cross_attention_kwargs""", """prompt_embeds""", } snake_case : Optional[int] = PipelineTesterMixin.required_optional_params - { """num_images_per_prompt""", """callback""", """callback_steps""", } snake_case : Optional[int] = TEXT_TO_IMAGE_BATCH_PARAMS snake_case : Any = False def _lowerCamelCase ( self ): torch.manual_seed(0 ) UpperCamelCase__ = 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 , ) UpperCamelCase__ = DDIMScheduler( beta_start=0.0_0085 , beta_end=0.012 , beta_schedule="""scaled_linear""" , clip_sample=__lowerCAmelCase , set_alpha_to_one=__lowerCAmelCase , ) torch.manual_seed(0 ) UpperCamelCase__ = AutoencoderKL( block_out_channels=(32, 64) , in_channels=3 , out_channels=3 , down_block_types=("""DownEncoderBlock2D""", """DownEncoderBlock2D""") , up_block_types=("""UpDecoderBlock2D""", """UpDecoderBlock2D""") , latent_channels=4 , ) torch.manual_seed(0 ) UpperCamelCase__ = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1E-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1000 , ) UpperCamelCase__ = CLIPTextModel(__lowerCAmelCase ) UpperCamelCase__ = CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" ) UpperCamelCase__ = { """unet""": unet, """scheduler""": scheduler, """vqvae""": vae, """bert""": text_encoder, """tokenizer""": tokenizer, } return components def _lowerCamelCase ( self , __lowerCAmelCase , __lowerCAmelCase=0 ): if str(__lowerCAmelCase ).startswith("""mps""" ): UpperCamelCase__ = torch.manual_seed(__lowerCAmelCase ) else: UpperCamelCase__ = torch.Generator(device=__lowerCAmelCase ).manual_seed(__lowerCAmelCase ) UpperCamelCase__ = { """prompt""": """A painting of a squirrel eating a burger""", """generator""": generator, """num_inference_steps""": 2, """guidance_scale""": 6.0, """output_type""": """numpy""", } return inputs def _lowerCamelCase ( self ): UpperCamelCase__ = """cpu""" # ensure determinism for the device-dependent torch.Generator UpperCamelCase__ = self.get_dummy_components() UpperCamelCase__ = LDMTextToImagePipeline(**__lowerCAmelCase ) pipe.to(__lowerCAmelCase ) pipe.set_progress_bar_config(disable=__lowerCAmelCase ) UpperCamelCase__ = self.get_dummy_inputs(__lowerCAmelCase ) UpperCamelCase__ = pipe(**__lowerCAmelCase ).images UpperCamelCase__ = image[0, -3:, -3:, -1] assert image.shape == (1, 16, 16, 3) UpperCamelCase__ = np.array([0.6101, 0.6156, 0.5622, 0.4895, 0.6661, 0.3804, 0.5748, 0.6136, 0.5014] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-3 @slow @require_torch_gpu class __SCREAMING_SNAKE_CASE ( unittest.TestCase ): def _lowerCamelCase ( self ): super().tearDown() gc.collect() torch.cuda.empty_cache() def _lowerCamelCase ( self , __lowerCAmelCase , __lowerCAmelCase=torch.floataa , __lowerCAmelCase=0 ): UpperCamelCase__ = torch.manual_seed(__lowerCAmelCase ) UpperCamelCase__ = np.random.RandomState(__lowerCAmelCase ).standard_normal((1, 4, 32, 32) ) UpperCamelCase__ = torch.from_numpy(__lowerCAmelCase ).to(device=__lowerCAmelCase , dtype=__lowerCAmelCase ) UpperCamelCase__ = { """prompt""": """A painting of a squirrel eating a burger""", """latents""": latents, """generator""": generator, """num_inference_steps""": 3, """guidance_scale""": 6.0, """output_type""": """numpy""", } return inputs def _lowerCamelCase ( self ): UpperCamelCase__ = LDMTextToImagePipeline.from_pretrained("""CompVis/ldm-text2im-large-256""" ).to(__lowerCAmelCase ) pipe.set_progress_bar_config(disable=__lowerCAmelCase ) UpperCamelCase__ = self.get_inputs(__lowerCAmelCase ) UpperCamelCase__ = pipe(**__lowerCAmelCase ).images UpperCamelCase__ = image[0, -3:, -3:, -1].flatten() assert image.shape == (1, 256, 256, 3) UpperCamelCase__ = np.array([0.5_1825, 0.5_2850, 0.5_2543, 0.5_4258, 0.5_2304, 0.5_2569, 0.5_4363, 0.5_5276, 0.5_6878] ) UpperCamelCase__ = np.abs(expected_slice - image_slice ).max() assert max_diff < 1E-3 @nightly @require_torch_gpu class __SCREAMING_SNAKE_CASE ( unittest.TestCase ): def _lowerCamelCase ( self ): super().tearDown() gc.collect() torch.cuda.empty_cache() def _lowerCamelCase ( self , __lowerCAmelCase , __lowerCAmelCase=torch.floataa , __lowerCAmelCase=0 ): UpperCamelCase__ = torch.manual_seed(__lowerCAmelCase ) UpperCamelCase__ = np.random.RandomState(__lowerCAmelCase ).standard_normal((1, 4, 32, 32) ) UpperCamelCase__ = torch.from_numpy(__lowerCAmelCase ).to(device=__lowerCAmelCase , dtype=__lowerCAmelCase ) UpperCamelCase__ = { """prompt""": """A painting of a squirrel eating a burger""", """latents""": latents, """generator""": generator, """num_inference_steps""": 50, """guidance_scale""": 6.0, """output_type""": """numpy""", } return inputs def _lowerCamelCase ( self ): UpperCamelCase__ = LDMTextToImagePipeline.from_pretrained("""CompVis/ldm-text2im-large-256""" ).to(__lowerCAmelCase ) pipe.set_progress_bar_config(disable=__lowerCAmelCase ) UpperCamelCase__ = self.get_inputs(__lowerCAmelCase ) UpperCamelCase__ = pipe(**__lowerCAmelCase ).images[0] UpperCamelCase__ = load_numpy( """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/ldm_text2img/ldm_large_256_ddim.npy""" ) UpperCamelCase__ = np.abs(expected_image - image ).max() assert max_diff < 1E-3

from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_torch_available, ) UpperCamelCase__ = { "configuration_swiftformer": [ "SWIFTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP", "SwiftFormerConfig", "SwiftFormerOnnxConfig", ] } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCamelCase__ = [ "SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST", "SwiftFormerForImageClassification", "SwiftFormerModel", "SwiftFormerPreTrainedModel", ] if TYPE_CHECKING: from .configuration_swiftformer import ( SWIFTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, SwiftFormerConfig, SwiftFormerOnnxConfig, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_swiftformer import ( SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, SwiftFormerForImageClassification, SwiftFormerModel, SwiftFormerPreTrainedModel, ) else: import sys UpperCamelCase__ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)