code
stringlengths
86
54.5k
code_codestyle
int64
0
371
style_context
stringlengths
87
49.2k
style_context_codestyle
int64
0
349
label
int64
0
1
from __future__ import annotations import os from typing import Any import requests UpperCamelCase__ : Any = """https://api.github.com""" # https://docs.github.com/en/free-pro-team@latest/rest/reference/users#get-the-authenticated-user UpperCamelCase__ : Union[str, Any] = BASE_URL + """/user""" # https://github.com/settings/tokens UpperCamelCase__ : Tuple = os.environ.get("""USER_TOKEN""", """""") def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> dict[Any, Any]: """simple docstring""" a = { '''Authorization''': f"""token {auth_token}""", '''Accept''': '''application/vnd.github.v3+json''', } return requests.get(snake_case_, headers=snake_case_ ).json() if __name__ == "__main__": # pragma: no cover if USER_TOKEN: for key, value in fetch_github_info(USER_TOKEN).items(): print(F"{key}: {value}") else: raise ValueError("""'USER_TOKEN' field cannot be empty.""")
330
# This script creates a super tiny model that is useful inside tests, when we just want to test that # the machinery works, without needing to the check the quality of the outcomes. # # This version creates a tiny vocab first, and then a tiny model - so the outcome is truly tiny - # all files ~60KB. As compared to taking a full-size model, reducing to the minimum its layers and # emb dimensions, but keeping the full vocab + merges files, leading to ~3MB in total for all files. # The latter is done by `fsmt-make-super-tiny-model.py`. # # It will be used then as "stas/tiny-wmt19-en-ru" from pathlib import Path import json import tempfile from transformers import FSMTTokenizer, FSMTConfig, FSMTForConditionalGeneration from transformers.models.fsmt.tokenization_fsmt import VOCAB_FILES_NAMES UpperCamelCase__ : Optional[Any] = """tiny-wmt19-en-ru""" # Build # borrowed from a test UpperCamelCase__ : Any = [ """l""", """o""", """w""", """e""", """r""", """s""", """t""", """i""", """d""", """n""", """w</w>""", """r</w>""", """t</w>""", """lo""", """low""", """er</w>""", """low</w>""", """lowest</w>""", """newer</w>""", """wider</w>""", """<unk>""", ] UpperCamelCase__ : List[Any] = dict(zip(vocab, range(len(vocab)))) UpperCamelCase__ : Any = ["""l o 123""", """lo w 1456""", """e r</w> 1789""", """"""] with tempfile.TemporaryDirectory() as tmpdirname: UpperCamelCase__ : Optional[Any] = Path(tmpdirname) UpperCamelCase__ : Tuple = build_dir / VOCAB_FILES_NAMES["""src_vocab_file"""] UpperCamelCase__ : int = build_dir / VOCAB_FILES_NAMES["""tgt_vocab_file"""] UpperCamelCase__ : Union[str, Any] = build_dir / VOCAB_FILES_NAMES["""merges_file"""] with open(src_vocab_file, """w""") as fp: fp.write(json.dumps(vocab_tokens)) with open(tgt_vocab_file, """w""") as fp: fp.write(json.dumps(vocab_tokens)) with open(merges_file, """w""") as fp: fp.write("""\n""".join(merges)) UpperCamelCase__ : Dict = FSMTTokenizer( langs=["""en""", """ru"""], src_vocab_size=len(vocab), tgt_vocab_size=len(vocab), src_vocab_file=src_vocab_file, tgt_vocab_file=tgt_vocab_file, merges_file=merges_file, ) UpperCamelCase__ : Union[str, Any] = FSMTConfig( langs=["""ru""", """en"""], src_vocab_size=1_000, tgt_vocab_size=1_000, d_model=4, encoder_layers=1, decoder_layers=1, encoder_ffn_dim=4, decoder_ffn_dim=4, encoder_attention_heads=1, decoder_attention_heads=1, ) UpperCamelCase__ : Union[str, Any] = FSMTForConditionalGeneration(config) print(F"num of params {tiny_model.num_parameters()}") # Test UpperCamelCase__ : List[str] = tokenizer(["""Making tiny model"""], return_tensors="""pt""") UpperCamelCase__ : Tuple = tiny_model(**batch) print("""test output:""", len(outputs.logits[0])) # Save tiny_model.half() # makes it smaller tiny_model.save_pretrained(mname_tiny) tokenizer.save_pretrained(mname_tiny) print(F"Generated {mname_tiny}") # Upload # transformers-cli upload tiny-wmt19-en-ru
330
1
from __future__ import annotations def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> int: """simple docstring""" if not nums: return 0 a = nums[0] a = 0 for num in nums[1:]: a , a = ( max_excluding + num, max(snake_case_, snake_case_ ), ) return max(snake_case_, snake_case_ ) if __name__ == "__main__": import doctest doctest.testmod()
330
import inspect import os import torch from transformers import AutoModel from transformers.testing_utils import mockenv_context from transformers.trainer_utils import set_seed import accelerate from accelerate.accelerator import Accelerator from accelerate.state import AcceleratorState from accelerate.test_utils.testing import ( AccelerateTestCase, TempDirTestCase, execute_subprocess_async, require_cuda, require_fsdp, require_multi_gpu, slow, ) from accelerate.utils.constants import ( FSDP_AUTO_WRAP_POLICY, FSDP_BACKWARD_PREFETCH, FSDP_SHARDING_STRATEGY, FSDP_STATE_DICT_TYPE, ) from accelerate.utils.dataclasses import FullyShardedDataParallelPlugin from accelerate.utils.other import patch_environment set_seed(42) UpperCamelCase__ : Optional[Any] = """bert-base-cased""" UpperCamelCase__ : int = """fp16""" UpperCamelCase__ : str = """bf16""" UpperCamelCase__ : List[Any] = [FPaa, BFaa] @require_fsdp @require_cuda class lowerCamelCase_ ( a_ ): def SCREAMING_SNAKE_CASE_ ( self : int ): '''simple docstring''' super().setUp() a = dict( ACCELERATE_USE_FSDP='''true''' ,MASTER_ADDR='''localhost''' ,MASTER_PORT='''10999''' ,RANK='''0''' ,LOCAL_RANK='''0''' ,WORLD_SIZE='''1''' ,) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import ShardingStrategy for i, strategy in enumerate(__lowerCamelCase ): a = self.dist_env.copy() a = F"""{i + 1}""" a = strategy with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() self.assertEqual(fsdp_plugin.sharding_strategy ,ShardingStrategy(i + 1 ) ) def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import BackwardPrefetch for i, prefetch_policy in enumerate(__lowerCamelCase ): a = self.dist_env.copy() a = prefetch_policy with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() if prefetch_policy == "NO_PREFETCH": self.assertIsNone(fsdp_plugin.backward_prefetch ) else: self.assertEqual(fsdp_plugin.backward_prefetch ,BackwardPrefetch(i + 1 ) ) def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType for i, state_dict_type in enumerate(__lowerCamelCase ): a = self.dist_env.copy() a = state_dict_type with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() self.assertEqual(fsdp_plugin.state_dict_type ,StateDictType(i + 1 ) ) if state_dict_type == "FULL_STATE_DICT": self.assertTrue(fsdp_plugin.state_dict_config.offload_to_cpu ) self.assertTrue(fsdp_plugin.state_dict_config.ranka_only ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ): '''simple docstring''' a = AutoModel.from_pretrained(__lowerCamelCase ) for policy in FSDP_AUTO_WRAP_POLICY: a = self.dist_env.copy() a = policy if policy == "TRANSFORMER_BASED_WRAP": a = '''BertLayer''' elif policy == "SIZE_BASED_WRAP": a = '''2000''' with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() fsdp_plugin.set_auto_wrap_policy(__lowerCamelCase ) if policy == "NO_WRAP": self.assertIsNone(fsdp_plugin.auto_wrap_policy ) else: self.assertIsNotNone(fsdp_plugin.auto_wrap_policy ) a = self.dist_env.copy() a = '''TRANSFORMER_BASED_WRAP''' a = '''T5Layer''' with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() with self.assertRaises(__lowerCamelCase ) as cm: fsdp_plugin.set_auto_wrap_policy(__lowerCamelCase ) self.assertTrue('''Could not find the transformer layer class to wrap in the model.''' in str(cm.exception ) ) a = self.dist_env.copy() a = '''SIZE_BASED_WRAP''' a = '''0''' with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() fsdp_plugin.set_auto_wrap_policy(__lowerCamelCase ) self.assertIsNone(fsdp_plugin.auto_wrap_policy ) def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import MixedPrecision from torch.distributed.fsdp.sharded_grad_scaler import ShardedGradScaler for mp_dtype in dtypes: a = self.dist_env.copy() a = mp_dtype with mockenv_context(**__lowerCamelCase ): a = Accelerator() if mp_dtype == "fp16": a = torch.floataa elif mp_dtype == "bf16": a = torch.bfloataa a = MixedPrecision(param_dtype=__lowerCamelCase ,reduce_dtype=__lowerCamelCase ,buffer_dtype=__lowerCamelCase ) self.assertEqual(accelerator.state.fsdp_plugin.mixed_precision_policy ,__lowerCamelCase ) if mp_dtype == FPaa: self.assertTrue(isinstance(accelerator.scaler ,__lowerCamelCase ) ) elif mp_dtype == BFaa: self.assertIsNone(accelerator.scaler ) AcceleratorState._reset_state(__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import CPUOffload for flag in [True, False]: a = self.dist_env.copy() a = str(__lowerCamelCase ).lower() with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() self.assertEqual(fsdp_plugin.cpu_offload ,CPUOffload(offload_params=__lowerCamelCase ) ) @require_fsdp @require_multi_gpu @slow class lowerCamelCase_ ( a_ ): def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' super().setUp() a = 0.82 a = [ '''fsdp_shard_grad_op_transformer_based_wrap''', '''fsdp_full_shard_transformer_based_wrap''', ] a = { '''multi_gpu_fp16''': 32_00, '''fsdp_shard_grad_op_transformer_based_wrap_fp16''': 20_00, '''fsdp_full_shard_transformer_based_wrap_fp16''': 19_00, # Disabling below test as it overwhelms the RAM memory usage # on CI self-hosted runner leading to tests getting killed. # "fsdp_full_shard_cpu_offload_transformer_based_wrap_fp32": 1500, # fp16 was leading to indefinite hang } a = 1_60 a = 1_60 a = inspect.getfile(accelerate.test_utils ) a = os.path.sep.join(mod_file.split(os.path.sep )[:-1] + ['''scripts''', '''external_deps'''] ) def SCREAMING_SNAKE_CASE_ ( self : List[str] ): '''simple docstring''' a = os.path.join(self.test_scripts_folder ,'''test_performance.py''' ) a = ['''accelerate''', '''launch''', '''--num_processes=2''', '''--num_machines=1''', '''--machine_rank=0''', '''--use_fsdp'''] for config in self.performance_configs: a = cmd.copy() for i, strategy in enumerate(__lowerCamelCase ): if strategy.lower() in config: cmd_config.append(F"""--fsdp_sharding_strategy={i+1}""" ) break if "fp32" in config: cmd_config.append('''--mixed_precision=no''' ) else: cmd_config.append('''--mixed_precision=fp16''' ) if "cpu_offload" in config: cmd_config.append('''--fsdp_offload_params=True''' ) for policy in FSDP_AUTO_WRAP_POLICY: if policy.lower() in config: cmd_config.append(F"""--fsdp_auto_wrap_policy={policy}""" ) break if policy == "TRANSFORMER_BASED_WRAP": cmd_config.append('''--fsdp_transformer_layer_cls_to_wrap=BertLayer''' ) elif policy == "SIZE_BASED_WRAP": cmd_config.append('''--fsdp_min_num_params=2000''' ) cmd_config.extend( [ self.test_file_path, F"""--output_dir={self.tmpdir}""", F"""--performance_lower_bound={self.performance_lower_bound}""", ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(__lowerCamelCase ,env=os.environ.copy() ) def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' a = os.path.join(self.test_scripts_folder ,'''test_checkpointing.py''' ) a = [ '''accelerate''', '''launch''', '''--num_processes=2''', '''--num_machines=1''', '''--machine_rank=0''', '''--use_fsdp''', '''--mixed_precision=fp16''', '''--fsdp_transformer_layer_cls_to_wrap=BertLayer''', ] for i, strategy in enumerate(__lowerCamelCase ): a = cmd.copy() cmd_config.append(F"""--fsdp_sharding_strategy={i+1}""" ) if strategy != "FULL_SHARD": continue a = len(__lowerCamelCase ) for state_dict_type in FSDP_STATE_DICT_TYPE: a = cmd_config[:state_dict_config_index] cmd_config.append(F"""--fsdp_state_dict_type={state_dict_type}""" ) cmd_config.extend( [ self.test_file_path, F"""--output_dir={self.tmpdir}""", '''--partial_train_epoch=1''', ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(__lowerCamelCase ,env=os.environ.copy() ) a = cmd_config[:-1] a = os.path.join(self.tmpdir ,'''epoch_0''' ) cmd_config.extend( [ F"""--resume_from_checkpoint={resume_from_checkpoint}""", ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(__lowerCamelCase ,env=os.environ.copy() ) def SCREAMING_SNAKE_CASE_ ( self : int ): '''simple docstring''' a = os.path.join(self.test_scripts_folder ,'''test_peak_memory_usage.py''' ) a = [ '''accelerate''', '''launch''', '''--num_processes=2''', '''--num_machines=1''', '''--machine_rank=0''', ] for spec, peak_mem_upper_bound in self.peak_memory_usage_upper_bound.items(): a = cmd.copy() if "fp16" in spec: cmd_config.extend(['''--mixed_precision=fp16'''] ) else: cmd_config.extend(['''--mixed_precision=no'''] ) if "multi_gpu" in spec: continue else: cmd_config.extend(['''--use_fsdp'''] ) for i, strategy in enumerate(__lowerCamelCase ): if strategy.lower() in spec: cmd_config.append(F"""--fsdp_sharding_strategy={i+1}""" ) break if "cpu_offload" in spec: cmd_config.append('''--fsdp_offload_params=True''' ) for policy in FSDP_AUTO_WRAP_POLICY: if policy.lower() in spec: cmd_config.append(F"""--fsdp_auto_wrap_policy={policy}""" ) break if policy == "TRANSFORMER_BASED_WRAP": cmd_config.append('''--fsdp_transformer_layer_cls_to_wrap=BertLayer''' ) elif policy == "SIZE_BASED_WRAP": cmd_config.append('''--fsdp_min_num_params=2000''' ) cmd_config.extend( [ self.test_file_path, F"""--output_dir={self.tmpdir}""", F"""--peak_memory_upper_bound={peak_mem_upper_bound}""", F"""--n_train={self.n_train}""", F"""--n_val={self.n_val}""", ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(__lowerCamelCase ,env=os.environ.copy() )
330
1
from typing import Dict, List, Optional, Union import numpy as np from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict from ...image_transforms import ( center_crop, convert_to_rgb, get_resize_output_image_size, normalize, rescale, resize, to_channel_dimension_format, ) from ...image_utils import ( OPENAI_CLIP_MEAN, OPENAI_CLIP_STD, ChannelDimension, ImageInput, PILImageResampling, make_list_of_images, to_numpy_array, valid_images, ) from ...utils import TensorType, is_vision_available, logging UpperCamelCase__ : List[str] = logging.get_logger(__name__) if is_vision_available(): import PIL class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = ['pixel_values'] def __init__( self : List[str] ,__lowerCamelCase : bool = True ,__lowerCamelCase : Dict[str, int] = None ,__lowerCamelCase : PILImageResampling = PILImageResampling.BICUBIC ,__lowerCamelCase : bool = True ,__lowerCamelCase : Dict[str, int] = None ,__lowerCamelCase : bool = True ,__lowerCamelCase : Union[int, float] = 1 / 2_55 ,__lowerCamelCase : bool = True ,__lowerCamelCase : Optional[Union[float, List[float]]] = None ,__lowerCamelCase : Optional[Union[float, List[float]]] = None ,__lowerCamelCase : bool = True ,**__lowerCamelCase : Optional[int] ,): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = size if size is not None else {'''shortest_edge''': 2_24} a = get_size_dict(__lowerCamelCase ,default_to_square=__lowerCamelCase ) a = crop_size if crop_size is not None else {'''height''': 2_24, '''width''': 2_24} a = get_size_dict(__lowerCamelCase ,default_to_square=__lowerCamelCase ,param_name='''crop_size''' ) a = do_resize a = size a = resample a = do_center_crop a = crop_size a = do_rescale a = rescale_factor a = do_normalize a = image_mean if image_mean is not None else OPENAI_CLIP_MEAN a = image_std if image_std is not None else OPENAI_CLIP_STD a = do_convert_rgb def SCREAMING_SNAKE_CASE_ ( self : Dict ,__lowerCamelCase : np.ndarray ,__lowerCamelCase : Dict[str, int] ,__lowerCamelCase : PILImageResampling = PILImageResampling.BICUBIC ,__lowerCamelCase : Optional[Union[str, ChannelDimension]] = None ,**__lowerCamelCase : Any ,): '''simple docstring''' a = get_size_dict(__lowerCamelCase ,default_to_square=__lowerCamelCase ) if "shortest_edge" not in size: raise ValueError(F"""The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}""" ) a = get_resize_output_image_size(__lowerCamelCase ,size=size['''shortest_edge'''] ,default_to_square=__lowerCamelCase ) return resize(__lowerCamelCase ,size=__lowerCamelCase ,resample=__lowerCamelCase ,data_format=__lowerCamelCase ,**__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : np.ndarray ,__lowerCamelCase : Dict[str, int] ,__lowerCamelCase : Optional[Union[str, ChannelDimension]] = None ,**__lowerCamelCase : str ,): '''simple docstring''' a = get_size_dict(__lowerCamelCase ) if "height" not in size or "width" not in size: raise ValueError(F"""The `size` parameter must contain the keys (height, width). Got {size.keys()}""" ) return center_crop(__lowerCamelCase ,size=(size['''height'''], size['''width''']) ,data_format=__lowerCamelCase ,**__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : np.ndarray ,__lowerCamelCase : Union[int, float] ,__lowerCamelCase : Optional[Union[str, ChannelDimension]] = None ,**__lowerCamelCase : Tuple ,): '''simple docstring''' return rescale(__lowerCamelCase ,scale=__lowerCamelCase ,data_format=__lowerCamelCase ,**__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : np.ndarray ,__lowerCamelCase : Union[float, List[float]] ,__lowerCamelCase : Union[float, List[float]] ,__lowerCamelCase : Optional[Union[str, ChannelDimension]] = None ,**__lowerCamelCase : List[Any] ,): '''simple docstring''' return normalize(__lowerCamelCase ,mean=__lowerCamelCase ,std=__lowerCamelCase ,data_format=__lowerCamelCase ,**__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : ImageInput ,__lowerCamelCase : bool = None ,__lowerCamelCase : Dict[str, int] = None ,__lowerCamelCase : PILImageResampling = None ,__lowerCamelCase : bool = None ,__lowerCamelCase : int = None ,__lowerCamelCase : bool = None ,__lowerCamelCase : float = None ,__lowerCamelCase : bool = None ,__lowerCamelCase : Optional[Union[float, List[float]]] = None ,__lowerCamelCase : Optional[Union[float, List[float]]] = None ,__lowerCamelCase : bool = None ,__lowerCamelCase : Optional[Union[str, TensorType]] = None ,__lowerCamelCase : Optional[ChannelDimension] = ChannelDimension.FIRST ,**__lowerCamelCase : Tuple ,): '''simple docstring''' a = do_resize if do_resize is not None else self.do_resize a = size if size is not None else self.size a = get_size_dict(__lowerCamelCase ,param_name='''size''' ,default_to_square=__lowerCamelCase ) a = resample if resample is not None else self.resample a = do_center_crop if do_center_crop is not None else self.do_center_crop a = crop_size if crop_size is not None else self.crop_size a = get_size_dict(__lowerCamelCase ,param_name='''crop_size''' ,default_to_square=__lowerCamelCase ) a = do_rescale if do_rescale is not None else self.do_rescale a = rescale_factor if rescale_factor is not None else self.rescale_factor a = do_normalize if do_normalize is not None else self.do_normalize a = image_mean if image_mean is not None else self.image_mean a = image_std if image_std is not None else self.image_std a = do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb a = 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_resize and size is None: raise ValueError('''Size must be specified if do_resize is True.''' ) if do_center_crop and crop_size is None: raise ValueError('''Crop size must be specified if do_center_crop is True.''' ) if do_rescale and rescale_factor is None: raise ValueError('''Rescale factor must be specified if do_rescale is True.''' ) if do_normalize and (image_mean is None or image_std is None): raise ValueError('''Image mean and std must be specified if do_normalize is True.''' ) # PIL RGBA images are converted to RGB if do_convert_rgb: a = [convert_to_rgb(__lowerCamelCase ) for image in images] # All transformations expect numpy arrays. a = [to_numpy_array(__lowerCamelCase ) for image in images] if do_resize: a = [self.resize(image=__lowerCamelCase ,size=__lowerCamelCase ,resample=__lowerCamelCase ) for image in images] if do_center_crop: a = [self.center_crop(image=__lowerCamelCase ,size=__lowerCamelCase ) for image in images] if do_rescale: a = [self.rescale(image=__lowerCamelCase ,scale=__lowerCamelCase ) for image in images] if do_normalize: a = [self.normalize(image=__lowerCamelCase ,mean=__lowerCamelCase ,std=__lowerCamelCase ) for image in images] a = [to_channel_dimension_format(__lowerCamelCase ,__lowerCamelCase ) for image in images] a = {'''pixel_values''': images} return BatchFeature(data=__lowerCamelCase ,tensor_type=__lowerCamelCase )
330
from __future__ import annotations import os from collections.abc import Mapping UpperCamelCase__ : Any = tuple[int, int] class lowerCamelCase_ : def __init__( self : Optional[Any] ,__lowerCamelCase : set[int] ,__lowerCamelCase : Mapping[EdgeT, int] ): '''simple docstring''' a = vertices a = { (min(__lowerCamelCase ), max(__lowerCamelCase )): weight for edge, weight in edges.items() } def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : EdgeT ,__lowerCamelCase : int ): '''simple docstring''' self.vertices.add(edge[0] ) self.vertices.add(edge[1] ) a = weight def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' a = Graph({min(self.vertices )} ,{} ) a = 42 a = 42 a = 42 a = 42 while len(subgraph.vertices ) < len(self.vertices ): a = max(self.edges.values() ) + 1 for edge, weight in self.edges.items(): if (edge[0] in subgraph.vertices) ^ (edge[1] in subgraph.vertices): if weight < min_weight: a = edge a = weight subgraph.add_edge(__lowerCamelCase ,__lowerCamelCase ) return subgraph def SCREAMING_SNAKE_CASE__ ( snake_case_ = "p107_network.txt" ) -> int: """simple docstring""" a = os.path.abspath(os.path.dirname(snake_case_ ) ) a = os.path.join(snake_case_, snake_case_ ) a = {} a = 42 a = 42 a = 42 with open(snake_case_ ) as f: a = f.read().strip().split('''\n''' ) a = [line.split(''',''' ) for line in data] for edgea in range(1, len(snake_case_ ) ): for edgea in range(snake_case_ ): if adjaceny_matrix[edgea][edgea] != "-": a = int(adjaceny_matrix[edgea][edgea] ) a = Graph(set(range(len(snake_case_ ) ) ), snake_case_ ) a = graph.prims_algorithm() a = sum(graph.edges.values() ) a = sum(subgraph.edges.values() ) return initial_total - optimal_total if __name__ == "__main__": print(F"{solution() = }")
330
1
from typing import Dict, List, Optional, Union import numpy as np from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict from ...image_transforms import ( center_crop, convert_to_rgb, get_resize_output_image_size, normalize, rescale, resize, to_channel_dimension_format, ) from ...image_utils import ( OPENAI_CLIP_MEAN, OPENAI_CLIP_STD, ChannelDimension, ImageInput, PILImageResampling, make_list_of_images, to_numpy_array, valid_images, ) from ...utils import TensorType, is_vision_available, logging UpperCamelCase__ : List[str] = logging.get_logger(__name__) if is_vision_available(): import PIL class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = ['pixel_values'] def __init__( self : Union[str, Any] ,__lowerCamelCase : bool = True ,__lowerCamelCase : Dict[str, int] = None ,__lowerCamelCase : PILImageResampling = PILImageResampling.BICUBIC ,__lowerCamelCase : bool = True ,__lowerCamelCase : Dict[str, int] = None ,__lowerCamelCase : bool = True ,__lowerCamelCase : Union[int, float] = 1 / 2_55 ,__lowerCamelCase : bool = True ,__lowerCamelCase : Optional[Union[float, List[float]]] = None ,__lowerCamelCase : Optional[Union[float, List[float]]] = None ,__lowerCamelCase : bool = True ,**__lowerCamelCase : Optional[Any] ,): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = size if size is not None else {'''shortest_edge''': 2_24} a = get_size_dict(__lowerCamelCase ,default_to_square=__lowerCamelCase ) a = crop_size if crop_size is not None else {'''height''': 2_24, '''width''': 2_24} a = get_size_dict(__lowerCamelCase ,default_to_square=__lowerCamelCase ,param_name='''crop_size''' ) a = do_resize a = size a = resample a = do_center_crop a = crop_size a = do_rescale a = rescale_factor a = do_normalize a = image_mean if image_mean is not None else OPENAI_CLIP_MEAN a = image_std if image_std is not None else OPENAI_CLIP_STD a = do_convert_rgb def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : np.ndarray ,__lowerCamelCase : Dict[str, int] ,__lowerCamelCase : PILImageResampling = PILImageResampling.BICUBIC ,__lowerCamelCase : Optional[Union[str, ChannelDimension]] = None ,**__lowerCamelCase : List[str] ,): '''simple docstring''' a = get_size_dict(__lowerCamelCase ,default_to_square=__lowerCamelCase ) if "shortest_edge" not in size: raise ValueError(F"""The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}""" ) a = get_resize_output_image_size(__lowerCamelCase ,size=size['''shortest_edge'''] ,default_to_square=__lowerCamelCase ) return resize(__lowerCamelCase ,size=__lowerCamelCase ,resample=__lowerCamelCase ,data_format=__lowerCamelCase ,**__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : np.ndarray ,__lowerCamelCase : Dict[str, int] ,__lowerCamelCase : Optional[Union[str, ChannelDimension]] = None ,**__lowerCamelCase : List[Any] ,): '''simple docstring''' a = get_size_dict(__lowerCamelCase ) if "height" not in size or "width" not in size: raise ValueError(F"""The `size` parameter must contain the keys (height, width). Got {size.keys()}""" ) return center_crop(__lowerCamelCase ,size=(size['''height'''], size['''width''']) ,data_format=__lowerCamelCase ,**__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Dict ,__lowerCamelCase : np.ndarray ,__lowerCamelCase : Union[int, float] ,__lowerCamelCase : Optional[Union[str, ChannelDimension]] = None ,**__lowerCamelCase : Dict ,): '''simple docstring''' return rescale(__lowerCamelCase ,scale=__lowerCamelCase ,data_format=__lowerCamelCase ,**__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Dict ,__lowerCamelCase : np.ndarray ,__lowerCamelCase : Union[float, List[float]] ,__lowerCamelCase : Union[float, List[float]] ,__lowerCamelCase : Optional[Union[str, ChannelDimension]] = None ,**__lowerCamelCase : List[Any] ,): '''simple docstring''' return normalize(__lowerCamelCase ,mean=__lowerCamelCase ,std=__lowerCamelCase ,data_format=__lowerCamelCase ,**__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ,__lowerCamelCase : ImageInput ,__lowerCamelCase : bool = None ,__lowerCamelCase : Dict[str, int] = None ,__lowerCamelCase : PILImageResampling = None ,__lowerCamelCase : bool = None ,__lowerCamelCase : int = None ,__lowerCamelCase : bool = None ,__lowerCamelCase : float = None ,__lowerCamelCase : bool = None ,__lowerCamelCase : Optional[Union[float, List[float]]] = None ,__lowerCamelCase : Optional[Union[float, List[float]]] = None ,__lowerCamelCase : bool = None ,__lowerCamelCase : Optional[Union[str, TensorType]] = None ,__lowerCamelCase : Optional[ChannelDimension] = ChannelDimension.FIRST ,**__lowerCamelCase : Any ,): '''simple docstring''' a = do_resize if do_resize is not None else self.do_resize a = size if size is not None else self.size a = get_size_dict(__lowerCamelCase ,param_name='''size''' ,default_to_square=__lowerCamelCase ) a = resample if resample is not None else self.resample a = do_center_crop if do_center_crop is not None else self.do_center_crop a = crop_size if crop_size is not None else self.crop_size a = get_size_dict(__lowerCamelCase ,param_name='''crop_size''' ,default_to_square=__lowerCamelCase ) a = do_rescale if do_rescale is not None else self.do_rescale a = rescale_factor if rescale_factor is not None else self.rescale_factor a = do_normalize if do_normalize is not None else self.do_normalize a = image_mean if image_mean is not None else self.image_mean a = image_std if image_std is not None else self.image_std a = do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb a = 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_resize and size is None: raise ValueError('''Size must be specified if do_resize is True.''' ) if do_center_crop and crop_size is None: raise ValueError('''Crop size must be specified if do_center_crop is True.''' ) if do_rescale and rescale_factor is None: raise ValueError('''Rescale factor must be specified if do_rescale is True.''' ) if do_normalize and (image_mean is None or image_std is None): raise ValueError('''Image mean and std must be specified if do_normalize is True.''' ) # PIL RGBA images are converted to RGB if do_convert_rgb: a = [convert_to_rgb(__lowerCamelCase ) for image in images] # All transformations expect numpy arrays. a = [to_numpy_array(__lowerCamelCase ) for image in images] if do_resize: a = [self.resize(image=__lowerCamelCase ,size=__lowerCamelCase ,resample=__lowerCamelCase ) for image in images] if do_center_crop: a = [self.center_crop(image=__lowerCamelCase ,size=__lowerCamelCase ) for image in images] if do_rescale: a = [self.rescale(image=__lowerCamelCase ,scale=__lowerCamelCase ) for image in images] if do_normalize: a = [self.normalize(image=__lowerCamelCase ,mean=__lowerCamelCase ,std=__lowerCamelCase ) for image in images] a = [to_channel_dimension_format(__lowerCamelCase ,__lowerCamelCase ) for image in images] a = {'''pixel_values''': images} return BatchFeature(data=__lowerCamelCase ,tensor_type=__lowerCamelCase )
330
from typing import Optional, Tuple, Union import tensorflow as tf from ...activations_tf import ACTaFN from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward from ...modeling_tf_outputs import ( TFBaseModelOutputWithNoAttention, TFBaseModelOutputWithPoolingAndNoAttention, TFSequenceClassifierOutput, ) from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs from ...tf_utils import shape_list from ...utils import logging from .configuration_regnet import RegNetConfig UpperCamelCase__ : List[Any] = logging.get_logger(__name__) # General docstring UpperCamelCase__ : List[Any] = """RegNetConfig""" # Base docstring UpperCamelCase__ : Dict = """facebook/regnet-y-040""" UpperCamelCase__ : int = [1, 1_088, 7, 7] # Image classification docstring UpperCamelCase__ : Optional[Any] = """facebook/regnet-y-040""" UpperCamelCase__ : Dict = """tabby, tabby cat""" UpperCamelCase__ : Dict = [ """facebook/regnet-y-040""", # See all regnet models at https://huggingface.co/models?filter=regnet ] class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : List[str] ,__lowerCamelCase : int ,__lowerCamelCase : int = 3 ,__lowerCamelCase : int = 1 ,__lowerCamelCase : int = 1 ,__lowerCamelCase : Optional[str] = "relu" ,**__lowerCamelCase : str ,): '''simple docstring''' super().__init__(**__lowerCamelCase ) # The padding and conv has been verified in # https://colab.research.google.com/gist/sayakpaul/854bc10eeaf21c9ee2119e0b9f3841a7/scratchpad.ipynb a = tf.keras.layers.ZeroPaddingaD(padding=kernel_size // 2 ) a = tf.keras.layers.ConvaD( filters=__lowerCamelCase ,kernel_size=__lowerCamelCase ,strides=__lowerCamelCase ,padding='''VALID''' ,groups=__lowerCamelCase ,use_bias=__lowerCamelCase ,name='''convolution''' ,) a = tf.keras.layers.BatchNormalization(epsilon=1e-5 ,momentum=0.9 ,name='''normalization''' ) a = ACTaFN[activation] if activation is not None else tf.identity def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : List[str] ): '''simple docstring''' a = self.convolution(self.padding(__lowerCamelCase ) ) a = self.normalization(__lowerCamelCase ) a = self.activation(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Any ,__lowerCamelCase : RegNetConfig ,**__lowerCamelCase : List[Any] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = config.num_channels a = TFRegNetConvLayer( out_channels=config.embedding_size ,kernel_size=3 ,stride=2 ,activation=config.hidden_act ,name='''embedder''' ,) def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : Optional[Any] ): '''simple docstring''' a = shape_list(__lowerCamelCase )[1] if tf.executing_eagerly() and 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.''' ) # When running on CPU, `tf.keras.layers.Conv2D` doesn't support `NCHW` format. # So change the input format from `NCHW` to `NHWC`. # shape = (batch_size, in_height, in_width, in_channels=num_channels) a = tf.transpose(__lowerCamelCase ,perm=(0, 2, 3, 1) ) a = self.embedder(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : str ,__lowerCamelCase : int ,__lowerCamelCase : int = 2 ,**__lowerCamelCase : Tuple ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = tf.keras.layers.ConvaD( filters=__lowerCamelCase ,kernel_size=1 ,strides=__lowerCamelCase ,use_bias=__lowerCamelCase ,name='''convolution''' ) a = tf.keras.layers.BatchNormalization(epsilon=1e-5 ,momentum=0.9 ,name='''normalization''' ) def SCREAMING_SNAKE_CASE_ ( self : Dict ,__lowerCamelCase : tf.Tensor ,__lowerCamelCase : bool = False ): '''simple docstring''' return self.normalization(self.convolution(__lowerCamelCase ) ,training=__lowerCamelCase ) class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : List[Any] ,__lowerCamelCase : int ,__lowerCamelCase : int ,**__lowerCamelCase : str ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = tf.keras.layers.GlobalAveragePoolingaD(keepdims=__lowerCamelCase ,name='''pooler''' ) a = [ tf.keras.layers.ConvaD(filters=__lowerCamelCase ,kernel_size=1 ,activation='''relu''' ,name='''attention.0''' ), tf.keras.layers.ConvaD(filters=__lowerCamelCase ,kernel_size=1 ,activation='''sigmoid''' ,name='''attention.2''' ), ] def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : Optional[Any] ): '''simple docstring''' a = self.pooler(__lowerCamelCase ) for layer_module in self.attention: a = layer_module(__lowerCamelCase ) a = hidden_state * pooled return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Union[str, Any] ,__lowerCamelCase : RegNetConfig ,__lowerCamelCase : int ,__lowerCamelCase : int ,__lowerCamelCase : int = 1 ,**__lowerCamelCase : Dict ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = in_channels != out_channels or stride != 1 a = max(1 ,out_channels // config.groups_width ) a = ( TFRegNetShortCut(__lowerCamelCase ,stride=__lowerCamelCase ,name='''shortcut''' ) if should_apply_shortcut else tf.keras.layers.Activation('''linear''' ,name='''shortcut''' ) ) # `self.layers` instead of `self.layer` because that is a reserved argument. a = [ TFRegNetConvLayer(__lowerCamelCase ,kernel_size=1 ,activation=config.hidden_act ,name='''layer.0''' ), TFRegNetConvLayer( __lowerCamelCase ,stride=__lowerCamelCase ,groups=__lowerCamelCase ,activation=config.hidden_act ,name='''layer.1''' ), TFRegNetConvLayer(__lowerCamelCase ,kernel_size=1 ,activation=__lowerCamelCase ,name='''layer.2''' ), ] a = ACTaFN[config.hidden_act] def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = hidden_state for layer_module in self.layers: a = layer_module(__lowerCamelCase ) a = self.shortcut(__lowerCamelCase ) hidden_state += residual a = self.activation(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Dict ,__lowerCamelCase : RegNetConfig ,__lowerCamelCase : int ,__lowerCamelCase : int ,__lowerCamelCase : int = 1 ,**__lowerCamelCase : List[str] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = in_channels != out_channels or stride != 1 a = max(1 ,out_channels // config.groups_width ) a = ( TFRegNetShortCut(__lowerCamelCase ,stride=__lowerCamelCase ,name='''shortcut''' ) if should_apply_shortcut else tf.keras.layers.Activation('''linear''' ,name='''shortcut''' ) ) a = [ TFRegNetConvLayer(__lowerCamelCase ,kernel_size=1 ,activation=config.hidden_act ,name='''layer.0''' ), TFRegNetConvLayer( __lowerCamelCase ,stride=__lowerCamelCase ,groups=__lowerCamelCase ,activation=config.hidden_act ,name='''layer.1''' ), TFRegNetSELayer(__lowerCamelCase ,reduced_channels=int(round(in_channels / 4 ) ) ,name='''layer.2''' ), TFRegNetConvLayer(__lowerCamelCase ,kernel_size=1 ,activation=__lowerCamelCase ,name='''layer.3''' ), ] a = ACTaFN[config.hidden_act] def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ,__lowerCamelCase : str ): '''simple docstring''' a = hidden_state for layer_module in self.layers: a = layer_module(__lowerCamelCase ) a = self.shortcut(__lowerCamelCase ) hidden_state += residual a = self.activation(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Optional[int] ,__lowerCamelCase : RegNetConfig ,__lowerCamelCase : int ,__lowerCamelCase : int ,__lowerCamelCase : int = 2 ,__lowerCamelCase : int = 2 ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = TFRegNetXLayer if config.layer_type == '''x''' else TFRegNetYLayer a = [ # downsampling is done in the first layer with stride of 2 layer(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ,stride=__lowerCamelCase ,name='''layers.0''' ), *[layer(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ,name=F"""layers.{i+1}""" ) for i in range(depth - 1 )], ] def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : int ): '''simple docstring''' for layer_module in self.layers: a = layer_module(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Union[str, Any] ,__lowerCamelCase : RegNetConfig ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = [] # based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input self.stages.append( TFRegNetStage( __lowerCamelCase ,config.embedding_size ,config.hidden_sizes[0] ,stride=2 if config.downsample_in_first_stage else 1 ,depth=config.depths[0] ,name='''stages.0''' ,) ) a = zip(config.hidden_sizes ,config.hidden_sizes[1:] ) for i, ((in_channels, out_channels), depth) in enumerate(zip(__lowerCamelCase ,config.depths[1:] ) ): self.stages.append(TFRegNetStage(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ,depth=__lowerCamelCase ,name=F"""stages.{i+1}""" ) ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : tf.Tensor ,__lowerCamelCase : bool = False ,__lowerCamelCase : bool = True ): '''simple docstring''' 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(__lowerCamelCase ) 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 TFBaseModelOutputWithNoAttention(last_hidden_state=__lowerCamelCase ,hidden_states=__lowerCamelCase ) @keras_serializable class lowerCamelCase_ ( tf.keras.layers.Layer ): SCREAMING_SNAKE_CASE_ = RegNetConfig def __init__( self : Dict ,__lowerCamelCase : Optional[int] ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = config a = TFRegNetEmbeddings(__lowerCamelCase ,name='''embedder''' ) a = TFRegNetEncoder(__lowerCamelCase ,name='''encoder''' ) a = tf.keras.layers.GlobalAveragePoolingaD(keepdims=__lowerCamelCase ,name='''pooler''' ) @unpack_inputs def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : tf.Tensor ,__lowerCamelCase : Optional[bool] = None ,__lowerCamelCase : Optional[bool] = None ,__lowerCamelCase : bool = False ,): '''simple docstring''' a = ( output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states ) a = return_dict if return_dict is not None else self.config.use_return_dict a = self.embedder(__lowerCamelCase ,training=__lowerCamelCase ) a = self.encoder( __lowerCamelCase ,output_hidden_states=__lowerCamelCase ,return_dict=__lowerCamelCase ,training=__lowerCamelCase ) a = encoder_outputs[0] a = self.pooler(__lowerCamelCase ) # Change to NCHW output format have uniformity in the modules a = tf.transpose(__lowerCamelCase ,perm=(0, 3, 1, 2) ) a = tf.transpose(__lowerCamelCase ,perm=(0, 3, 1, 2) ) # Change the other hidden state outputs to NCHW as well if output_hidden_states: a = tuple([tf.transpose(__lowerCamelCase ,perm=(0, 3, 1, 2) ) for h in encoder_outputs[1]] ) if not return_dict: return (last_hidden_state, pooled_output) + encoder_outputs[1:] return TFBaseModelOutputWithPoolingAndNoAttention( last_hidden_state=__lowerCamelCase ,pooler_output=__lowerCamelCase ,hidden_states=hidden_states if output_hidden_states else encoder_outputs.hidden_states ,) class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = RegNetConfig SCREAMING_SNAKE_CASE_ = 'regnet' SCREAMING_SNAKE_CASE_ = 'pixel_values' @property def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 2_24, 2_24) ,dtype=tf.floataa )} UpperCamelCase__ : Union[str, Any] = R""" Parameters: This model is a Tensorflow [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a regular Tensorflow Module and refer to the Tensorflow documentation for all matter related to general usage and behavior. config ([`RegNetConfig`]): 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 [`~TFPreTrainedModel.from_pretrained`] method to load the model weights. """ UpperCamelCase__ : List[str] = R""" Args: pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`): Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See [`ConveNextImageProcessor.__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 RegNet model outputting raw features without any specific head on top.' , a_ , ) class lowerCamelCase_ ( a_ ): def __init__( self : Optional[int] ,__lowerCamelCase : RegNetConfig ,*__lowerCamelCase : int ,**__lowerCamelCase : Union[str, Any] ): '''simple docstring''' super().__init__(__lowerCamelCase ,*__lowerCamelCase ,**__lowerCamelCase ) a = TFRegNetMainLayer(__lowerCamelCase ,name='''regnet''' ) @unpack_inputs @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 SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : tf.Tensor ,__lowerCamelCase : Optional[bool] = None ,__lowerCamelCase : Optional[bool] = None ,__lowerCamelCase : List[str]=False ,): '''simple docstring''' a = ( output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states ) a = return_dict if return_dict is not None else self.config.use_return_dict a = self.regnet( pixel_values=__lowerCamelCase ,output_hidden_states=__lowerCamelCase ,return_dict=__lowerCamelCase ,training=__lowerCamelCase ,) if not return_dict: return (outputs[0],) + outputs[1:] return TFBaseModelOutputWithPoolingAndNoAttention( last_hidden_state=outputs.last_hidden_state ,pooler_output=outputs.pooler_output ,hidden_states=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 ' , a_ , ) class lowerCamelCase_ ( a_ , a_ ): def __init__( self : Optional[int] ,__lowerCamelCase : RegNetConfig ,*__lowerCamelCase : str ,**__lowerCamelCase : Any ): '''simple docstring''' super().__init__(__lowerCamelCase ,*__lowerCamelCase ,**__lowerCamelCase ) a = config.num_labels a = TFRegNetMainLayer(__lowerCamelCase ,name='''regnet''' ) # classification head a = [ tf.keras.layers.Flatten(), tf.keras.layers.Dense(config.num_labels ,name='''classifier.1''' ) if config.num_labels > 0 else tf.identity, ] @unpack_inputs @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 SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : tf.Tensor = None ,__lowerCamelCase : tf.Tensor = None ,__lowerCamelCase : bool = None ,__lowerCamelCase : bool = None ,__lowerCamelCase : Dict=False ,): '''simple docstring''' a = ( output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states ) a = return_dict if return_dict is not None else self.config.use_return_dict a = self.regnet( __lowerCamelCase ,output_hidden_states=__lowerCamelCase ,return_dict=__lowerCamelCase ,training=__lowerCamelCase ) a = outputs.pooler_output if return_dict else outputs[1] a = self.classifier[0](__lowerCamelCase ) a = self.classifier[1](__lowerCamelCase ) a = None if labels is None else self.hf_compute_loss(labels=__lowerCamelCase ,logits=__lowerCamelCase ) if not return_dict: a = (logits,) + outputs[2:] return ((loss,) + output) if loss is not None else output return TFSequenceClassifierOutput(loss=__lowerCamelCase ,logits=__lowerCamelCase ,hidden_states=outputs.hidden_states )
330
1
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 SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Optional[int]: """simple docstring""" a = 3_8_4 a = 7 if "tiny" in model_name: a = 9_6 a = (2, 2, 6, 2) a = (3, 6, 1_2, 2_4) elif "small" in model_name: a = 9_6 a = (2, 2, 1_8, 2) a = (3, 6, 1_2, 2_4) elif "base" in model_name: a = 1_2_8 a = (2, 2, 1_8, 2) a = (4, 8, 1_6, 3_2) a = 1_2 a = 5_1_2 elif "large" in model_name: a = 1_9_2 a = (2, 2, 1_8, 2) a = (6, 1_2, 2_4, 4_8) a = 1_2 a = 7_6_8 # set label information a = 1_5_0 a = '''huggingface/label-files''' a = '''ade20k-id2label.json''' a = json.load(open(hf_hub_download(snake_case_, snake_case_, repo_type='''dataset''' ), '''r''' ) ) a = {int(snake_case_ ): v for k, v in idalabel.items()} a = {v: k for k, v in idalabel.items()} a = SwinConfig( embed_dim=snake_case_, depths=snake_case_, num_heads=snake_case_, window_size=snake_case_, out_features=['''stage1''', '''stage2''', '''stage3''', '''stage4'''], ) a = UperNetConfig( backbone_config=snake_case_, auxiliary_in_channels=snake_case_, num_labels=snake_case_, idalabel=snake_case_, labelaid=snake_case_, ) return config def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Any: """simple docstring""" a = [] # 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 SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> Union[str, Any]: """simple docstring""" a = dct.pop(snake_case_ ) a = val def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> List[str]: """simple docstring""" a = [int(backbone_config.embed_dim * 2**i ) for i in range(len(backbone_config.depths ) )] for i in range(len(backbone_config.depths ) ): a = 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) a = state_dict.pop(f"""backbone.stages.{i}.blocks.{j}.attn.w_msa.qkv.weight""" ) a = 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 a = in_proj_weight[:dim, :] a = in_proj_bias[: dim] a = in_proj_weight[ dim : dim * 2, : ] a = in_proj_bias[ dim : dim * 2 ] a = in_proj_weight[ -dim :, : ] a = in_proj_bias[-dim :] # fmt: on def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> List[Any]: """simple docstring""" a , a = x.shape a = x.reshape(snake_case_, 4, in_channel // 4 ) a = x[:, [0, 2, 1, 3], :].transpose(1, 2 ).reshape(snake_case_, snake_case_ ) return x def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> List[Any]: """simple docstring""" a , a = x.shape a = x.reshape(snake_case_, in_channel // 4, 4 ) a = x[:, :, [0, 2, 1, 3]].transpose(1, 2 ).reshape(snake_case_, snake_case_ ) return x def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> int: """simple docstring""" a = x.shape[0] a = x.reshape(4, in_channel // 4 ) a = x[[0, 2, 1, 3], :].transpose(0, 1 ).reshape(snake_case_ ) return x def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Tuple: """simple docstring""" a = x.shape[0] a = x.reshape(in_channel // 4, 4 ) a = x[:, [0, 2, 1, 3]].transpose(0, 1 ).reshape(snake_case_ ) return x def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> Tuple: """simple docstring""" a = { '''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''', } a = model_name_to_url[model_name] a = torch.hub.load_state_dict_from_url(snake_case_, map_location='''cpu''', file_name=snake_case_ )[ '''state_dict''' ] for name, param in state_dict.items(): print(snake_case_, param.shape ) a = get_upernet_config(snake_case_ ) a = UperNetForSemanticSegmentation(snake_case_ ) model.eval() # replace "bn" => "batch_norm" for key in state_dict.copy().keys(): a = state_dict.pop(snake_case_ ) if "bn" in key: a = key.replace('''bn''', '''batch_norm''' ) a = val # rename keys a = create_rename_keys(snake_case_ ) for src, dest in rename_keys: rename_key(snake_case_, snake_case_, snake_case_ ) read_in_q_k_v(snake_case_, config.backbone_config ) # fix downsample parameters for key, value in state_dict.items(): if "downsample" in key: if "reduction" in key: a = reverse_correct_unfold_reduction_order(snake_case_ ) if "norm" in key: a = reverse_correct_unfold_norm_order(snake_case_ ) model.load_state_dict(snake_case_ ) # verify on image a = '''https://huggingface.co/datasets/hf-internal-testing/fixtures_ade20k/resolve/main/ADE_val_00000001.jpg''' a = Image.open(requests.get(snake_case_, stream=snake_case_ ).raw ).convert('''RGB''' ) a = SegformerImageProcessor() a = processor(snake_case_, return_tensors='''pt''' ).pixel_values with torch.no_grad(): a = model(snake_case_ ) a = outputs.logits print(logits.shape ) print('''First values of logits:''', logits[0, 0, :3, :3] ) # assert values if model_name == "upernet-swin-tiny": a = 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": a = 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": a = 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": a = 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], snake_case_, 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(snake_case_ ) print(f"""Saving processor to {pytorch_dump_folder_path}""" ) processor.save_pretrained(snake_case_ ) if push_to_hub: print(f"""Pushing model and processor for {model_name} to hub""" ) model.push_to_hub(f"""openmmlab/{model_name}""" ) processor.push_to_hub(f"""openmmlab/{model_name}""" ) if __name__ == "__main__": UpperCamelCase__ : Optional[Any] = argparse.ArgumentParser() # Required parameters parser.add_argument( """--model_name""", default="""upernet-swin-tiny""", type=str, choices=[F"upernet-swin-{size}" for size in ["""tiny""", """small""", """base""", """large"""]], help="""Name of the Swin + UperNet model you'd like to convert.""", ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory.""" ) parser.add_argument( """--push_to_hub""", action="""store_true""", help="""Whether or not to push the converted model to the 🤗 hub.""" ) UpperCamelCase__ : List[str] = parser.parse_args() convert_upernet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
330
from typing import List from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCamelCase__ : Union[str, Any] = logging.get_logger(__name__) UpperCamelCase__ : List[str] = { """snap-research/efficientformer-l1-300""": ( """https://huggingface.co/snap-research/efficientformer-l1-300/resolve/main/config.json""" ), } class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = 'efficientformer' def __init__( self : Optional[int] ,__lowerCamelCase : List[int] = [3, 2, 6, 4] ,__lowerCamelCase : List[int] = [48, 96, 2_24, 4_48] ,__lowerCamelCase : List[bool] = [True, True, True, True] ,__lowerCamelCase : int = 4_48 ,__lowerCamelCase : int = 32 ,__lowerCamelCase : int = 4 ,__lowerCamelCase : int = 7 ,__lowerCamelCase : int = 5 ,__lowerCamelCase : int = 8 ,__lowerCamelCase : int = 4 ,__lowerCamelCase : float = 0.0 ,__lowerCamelCase : int = 16 ,__lowerCamelCase : int = 3 ,__lowerCamelCase : int = 3 ,__lowerCamelCase : int = 3 ,__lowerCamelCase : int = 2 ,__lowerCamelCase : int = 1 ,__lowerCamelCase : float = 0.0 ,__lowerCamelCase : int = 1 ,__lowerCamelCase : bool = True ,__lowerCamelCase : bool = True ,__lowerCamelCase : float = 1e-5 ,__lowerCamelCase : str = "gelu" ,__lowerCamelCase : float = 0.02 ,__lowerCamelCase : float = 1e-12 ,__lowerCamelCase : int = 2_24 ,__lowerCamelCase : float = 1e-05 ,**__lowerCamelCase : Dict ,): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = hidden_act a = hidden_dropout_prob a = hidden_sizes a = num_hidden_layers a = num_attention_heads a = initializer_range a = layer_norm_eps a = patch_size a = num_channels a = depths a = mlp_expansion_ratio a = downsamples a = dim a = key_dim a = attention_ratio a = resolution a = pool_size a = downsample_patch_size a = downsample_stride a = downsample_pad a = drop_path_rate a = num_metaad_blocks a = distillation a = use_layer_scale a = layer_scale_init_value a = image_size a = batch_norm_eps
330
1
import unittest from transformers import MraConfig, is_torch_available from transformers.testing_utils import require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask if is_torch_available(): import torch from transformers import ( MraForMaskedLM, MraForMultipleChoice, MraForQuestionAnswering, MraForSequenceClassification, MraForTokenClassification, MraModel, ) from transformers.models.mra.modeling_mra import MRA_PRETRAINED_MODEL_ARCHIVE_LIST class lowerCamelCase_ : def __init__( self : List[str] ,__lowerCamelCase : List[Any] ,__lowerCamelCase : List[Any]=2 ,__lowerCamelCase : Any=8 ,__lowerCamelCase : Union[str, Any]=True ,__lowerCamelCase : Tuple=True ,__lowerCamelCase : Union[str, Any]=True ,__lowerCamelCase : List[Any]=True ,__lowerCamelCase : List[Any]=99 ,__lowerCamelCase : Dict=16 ,__lowerCamelCase : Dict=5 ,__lowerCamelCase : Tuple=2 ,__lowerCamelCase : Union[str, Any]=36 ,__lowerCamelCase : str="gelu" ,__lowerCamelCase : str=0.0 ,__lowerCamelCase : Dict=0.0 ,__lowerCamelCase : str=5_12 ,__lowerCamelCase : Optional[int]=16 ,__lowerCamelCase : List[Any]=2 ,__lowerCamelCase : Optional[Any]=0.02 ,__lowerCamelCase : Any=3 ,__lowerCamelCase : Optional[int]=4 ,__lowerCamelCase : Optional[Any]=None ,): '''simple docstring''' a = parent a = batch_size a = seq_length a = is_training a = use_input_mask a = use_token_type_ids a = use_labels a = vocab_size a = hidden_size a = num_hidden_layers a = num_attention_heads a = intermediate_size a = hidden_act a = hidden_dropout_prob a = attention_probs_dropout_prob a = max_position_embeddings a = type_vocab_size a = type_sequence_label_size a = initializer_range a = num_labels a = num_choices a = scope def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ): '''simple docstring''' a = ids_tensor([self.batch_size, self.seq_length] ,self.vocab_size ) a = None if self.use_input_mask: a = random_attention_mask([self.batch_size, self.seq_length] ) a = None if self.use_token_type_ids: a = ids_tensor([self.batch_size, self.seq_length] ,self.type_vocab_size ) a = None a = None a = None if self.use_labels: a = ids_tensor([self.batch_size] ,self.type_sequence_label_size ) a = ids_tensor([self.batch_size, self.seq_length] ,self.num_labels ) a = ids_tensor([self.batch_size] ,self.num_choices ) a = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' return MraConfig( vocab_size=self.vocab_size ,hidden_size=self.hidden_size ,num_hidden_layers=self.num_hidden_layers ,num_attention_heads=self.num_attention_heads ,intermediate_size=self.intermediate_size ,hidden_act=self.hidden_act ,hidden_dropout_prob=self.hidden_dropout_prob ,attention_probs_dropout_prob=self.attention_probs_dropout_prob ,max_position_embeddings=self.max_position_embeddings ,type_vocab_size=self.type_vocab_size ,is_decoder=__lowerCamelCase ,initializer_range=self.initializer_range ,) def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' a = self.get_config() a = 3_00 return config def SCREAMING_SNAKE_CASE_ ( self : int ): '''simple docstring''' ( ( a ) , ( a ) , ( a ) , ( a ) , ( a ) , ( a ) , ( a ) , ) = self.prepare_config_and_inputs() a = True a = floats_tensor([self.batch_size, self.seq_length, self.hidden_size] ) a = ids_tensor([self.batch_size, self.seq_length] ,vocab_size=2 ) return ( config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels, encoder_hidden_states, encoder_attention_mask, ) def SCREAMING_SNAKE_CASE_ ( self : Dict ,__lowerCamelCase : Dict ,__lowerCamelCase : Tuple ,__lowerCamelCase : Tuple ,__lowerCamelCase : List[str] ,__lowerCamelCase : Any ,__lowerCamelCase : Tuple ,__lowerCamelCase : Any ): '''simple docstring''' a = MraModel(config=__lowerCamelCase ) model.to(__lowerCamelCase ) model.eval() a = model(__lowerCamelCase ,attention_mask=__lowerCamelCase ,token_type_ids=__lowerCamelCase ) a = model(__lowerCamelCase ,token_type_ids=__lowerCamelCase ) a = model(__lowerCamelCase ) self.parent.assertEqual(result.last_hidden_state.shape ,(self.batch_size, self.seq_length, self.hidden_size) ) def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : Union[str, Any] ,__lowerCamelCase : Any ,__lowerCamelCase : Tuple ,__lowerCamelCase : List[Any] ,__lowerCamelCase : int ,__lowerCamelCase : List[Any] ,__lowerCamelCase : Optional[Any] ,): '''simple docstring''' a = True a = MraModel(__lowerCamelCase ) model.to(__lowerCamelCase ) model.eval() a = model( __lowerCamelCase ,attention_mask=__lowerCamelCase ,token_type_ids=__lowerCamelCase ,encoder_hidden_states=__lowerCamelCase ,encoder_attention_mask=__lowerCamelCase ,) a = model( __lowerCamelCase ,attention_mask=__lowerCamelCase ,token_type_ids=__lowerCamelCase ,encoder_hidden_states=__lowerCamelCase ,) a = model(__lowerCamelCase ,attention_mask=__lowerCamelCase ,token_type_ids=__lowerCamelCase ) self.parent.assertEqual(result.last_hidden_state.shape ,(self.batch_size, self.seq_length, self.hidden_size) ) def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ,__lowerCamelCase : Union[str, Any] ,__lowerCamelCase : Optional[int] ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : List[Any] ,__lowerCamelCase : List[Any] ,__lowerCamelCase : Any ,__lowerCamelCase : Optional[Any] ): '''simple docstring''' a = MraForMaskedLM(config=__lowerCamelCase ) model.to(__lowerCamelCase ) model.eval() a = model(__lowerCamelCase ,attention_mask=__lowerCamelCase ,token_type_ids=__lowerCamelCase ,labels=__lowerCamelCase ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.seq_length, self.vocab_size) ) def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ,__lowerCamelCase : str ,__lowerCamelCase : str ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : Union[str, Any] ,__lowerCamelCase : Dict ,__lowerCamelCase : Union[str, Any] ,__lowerCamelCase : Any ): '''simple docstring''' a = MraForQuestionAnswering(config=__lowerCamelCase ) model.to(__lowerCamelCase ) model.eval() a = model( __lowerCamelCase ,attention_mask=__lowerCamelCase ,token_type_ids=__lowerCamelCase ,start_positions=__lowerCamelCase ,end_positions=__lowerCamelCase ,) self.parent.assertEqual(result.start_logits.shape ,(self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape ,(self.batch_size, self.seq_length) ) def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ,__lowerCamelCase : Any ,__lowerCamelCase : Any ,__lowerCamelCase : Optional[int] ,__lowerCamelCase : Dict ,__lowerCamelCase : Dict ,__lowerCamelCase : Optional[int] ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = self.num_labels a = MraForSequenceClassification(__lowerCamelCase ) model.to(__lowerCamelCase ) model.eval() a = model(__lowerCamelCase ,attention_mask=__lowerCamelCase ,token_type_ids=__lowerCamelCase ,labels=__lowerCamelCase ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.num_labels) ) def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : str ,__lowerCamelCase : str ,__lowerCamelCase : List[str] ,__lowerCamelCase : Union[str, Any] ,__lowerCamelCase : List[Any] ,__lowerCamelCase : Union[str, Any] ,__lowerCamelCase : List[str] ): '''simple docstring''' a = self.num_labels a = MraForTokenClassification(config=__lowerCamelCase ) model.to(__lowerCamelCase ) model.eval() a = model(__lowerCamelCase ,attention_mask=__lowerCamelCase ,token_type_ids=__lowerCamelCase ,labels=__lowerCamelCase ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.seq_length, self.num_labels) ) def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : Union[str, Any] ,__lowerCamelCase : Dict ,__lowerCamelCase : List[Any] ,__lowerCamelCase : List[str] ,__lowerCamelCase : List[Any] ,__lowerCamelCase : str ): '''simple docstring''' a = self.num_choices a = MraForMultipleChoice(config=__lowerCamelCase ) model.to(__lowerCamelCase ) model.eval() a = input_ids.unsqueeze(1 ).expand(-1 ,self.num_choices ,-1 ).contiguous() a = token_type_ids.unsqueeze(1 ).expand(-1 ,self.num_choices ,-1 ).contiguous() a = input_mask.unsqueeze(1 ).expand(-1 ,self.num_choices ,-1 ).contiguous() a = model( __lowerCamelCase ,attention_mask=__lowerCamelCase ,token_type_ids=__lowerCamelCase ,labels=__lowerCamelCase ,) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.num_choices) ) def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' a = self.prepare_config_and_inputs() ( ( a ) , ( a ) , ( a ) , ( a ) , ( a ) , ( a ) , ( a ) , ) = config_and_inputs a = {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask} return config, inputs_dict @require_torch class lowerCamelCase_ ( a_ , unittest.TestCase ): SCREAMING_SNAKE_CASE_ = ( ( MraModel, MraForMaskedLM, MraForMultipleChoice, MraForQuestionAnswering, MraForSequenceClassification, MraForTokenClassification, ) if is_torch_available() else () ) SCREAMING_SNAKE_CASE_ = False SCREAMING_SNAKE_CASE_ = False SCREAMING_SNAKE_CASE_ = False SCREAMING_SNAKE_CASE_ = False SCREAMING_SNAKE_CASE_ = () def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ): '''simple docstring''' a = MraModelTester(self ) a = ConfigTester(self ,config_class=__lowerCamelCase ,hidden_size=37 ) def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' self.config_tester.run_common_tests() def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' a = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' a = self.model_tester.prepare_config_and_inputs() for type in ["absolute", "relative_key", "relative_key_query"]: a = type self.model_tester.create_and_check_model(*__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ): '''simple docstring''' a = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' a = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_multiple_choice(*__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : int ): '''simple docstring''' a = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_question_answering(*__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : int ): '''simple docstring''' a = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_sequence_classification(*__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ): '''simple docstring''' a = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*__lowerCamelCase ) @slow def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' for model_name in MRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: a = MraModel.from_pretrained(__lowerCamelCase ) self.assertIsNotNone(__lowerCamelCase ) @unittest.skip(reason='''MRA does not output attentions''' ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ): '''simple docstring''' return @require_torch class lowerCamelCase_ ( unittest.TestCase ): @slow def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' a = MraModel.from_pretrained('''uw-madison/mra-base-512-4''' ) a = torch.arange(2_56 ).unsqueeze(0 ) with torch.no_grad(): a = model(__lowerCamelCase )[0] a = torch.Size((1, 2_56, 7_68) ) self.assertEqual(output.shape ,__lowerCamelCase ) a = torch.tensor( [[[-0.0_140, 0.0_830, -0.0_381], [0.1_546, 0.1_402, 0.0_220], [0.1_162, 0.0_851, 0.0_165]]] ) self.assertTrue(torch.allclose(output[:, :3, :3] ,__lowerCamelCase ,atol=1e-4 ) ) @slow def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ): '''simple docstring''' a = MraForMaskedLM.from_pretrained('''uw-madison/mra-base-512-4''' ) a = torch.arange(2_56 ).unsqueeze(0 ) with torch.no_grad(): a = model(__lowerCamelCase )[0] a = 5_02_65 a = torch.Size((1, 2_56, vocab_size) ) self.assertEqual(output.shape ,__lowerCamelCase ) a = torch.tensor( [[[9.2_595, -3.6_038, 11.8_819], [9.3_869, -3.2_693, 11.0_956], [11.8_524, -3.4_938, 13.1_210]]] ) self.assertTrue(torch.allclose(output[:, :3, :3] ,__lowerCamelCase ,atol=1e-4 ) ) @slow def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' a = MraForMaskedLM.from_pretrained('''uw-madison/mra-base-4096-8-d3''' ) a = torch.arange(40_96 ).unsqueeze(0 ) with torch.no_grad(): a = model(__lowerCamelCase )[0] a = 5_02_65 a = torch.Size((1, 40_96, vocab_size) ) self.assertEqual(output.shape ,__lowerCamelCase ) a = torch.tensor( [[[5.4_789, -2.3_564, 7.5_064], [7.9_067, -1.3_369, 9.9_668], [9.0_712, -1.8_106, 7.0_380]]] ) self.assertTrue(torch.allclose(output[:, :3, :3] ,__lowerCamelCase ,atol=1e-4 ) )
330
import argparse from typing import Dict import tensorflow as tf import torch from tqdm import tqdm from transformers import BigBirdPegasusConfig, BigBirdPegasusForConditionalGeneration UpperCamelCase__ : Any = [ # tf -> hf ("""/""", """."""), ("""layer_""", """layers."""), ("""kernel""", """weight"""), ("""beta""", """bias"""), ("""gamma""", """weight"""), ("""pegasus""", """model"""), ] UpperCamelCase__ : Optional[Any] = [ (""".output.dense""", """.fc2"""), ("""intermediate.LayerNorm""", """final_layer_norm"""), ("""intermediate.dense""", """fc1"""), ] UpperCamelCase__ : Optional[Any] = ( INIT_COMMON + [ ("""attention.self.LayerNorm""", """self_attn_layer_norm"""), ("""attention.output.dense""", """self_attn.out_proj"""), ("""attention.self""", """self_attn"""), ("""attention.encdec.LayerNorm""", """encoder_attn_layer_norm"""), ("""attention.encdec_output.dense""", """encoder_attn.out_proj"""), ("""attention.encdec""", """encoder_attn"""), ("""key""", """k_proj"""), ("""value""", """v_proj"""), ("""query""", """q_proj"""), ("""decoder.LayerNorm""", """decoder.layernorm_embedding"""), ] + END_COMMON ) UpperCamelCase__ : List[str] = ( INIT_COMMON + [ ("""embeddings.word_embeddings""", """shared.weight"""), ("""embeddings.position_embeddings""", """embed_positions.weight"""), ("""attention.self.LayerNorm""", """self_attn_layer_norm"""), ("""attention.output.dense""", """self_attn.output"""), ("""attention.self""", """self_attn.self"""), ("""encoder.LayerNorm""", """encoder.layernorm_embedding"""), ] + END_COMMON ) UpperCamelCase__ : Optional[int] = [ """encdec/key/bias""", """encdec/query/bias""", """encdec/value/bias""", """self/key/bias""", """self/query/bias""", """self/value/bias""", """encdec_output/dense/bias""", """attention/output/dense/bias""", ] def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> List[Any]: """simple docstring""" for tf_name, hf_name in patterns: a = k.replace(snake_case_, snake_case_ ) return k def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> BigBirdPegasusForConditionalGeneration: """simple docstring""" a = BigBirdPegasusConfig(**snake_case_ ) a = BigBirdPegasusForConditionalGeneration(snake_case_ ) a = torch_model.state_dict() a = {} # separating decoder weights a = {k: tf_weights[k] for k in tf_weights if k.startswith('''pegasus/decoder''' )} a = {k: tf_weights[k] for k in tf_weights if not k.startswith('''pegasus/decoder''' )} for k, v in tqdm(decoder_weights.items(), '''tf -> hf conversion''' ): a = [k.endswith(snake_case_ ) for ending in KEYS_TO_IGNORE] if any(snake_case_ ): continue a = DECODER_PATTERNS a = rename_state_dict_key(snake_case_, snake_case_ ) if new_k not in state_dict: raise ValueError(f"""could not find new key {new_k} in state dict. (converted from {k})""" ) if any(True if i in k else False for i in ['''dense''', '''query''', '''key''', '''value'''] ): a = v.T a = torch.from_numpy(snake_case_ ) assert v.shape == state_dict[new_k].shape, f"""{new_k}, {k}, {v.shape}, {state_dict[new_k].shape}""" for k, v in tqdm(remaining_weights.items(), '''tf -> hf conversion''' ): a = [k.endswith(snake_case_ ) for ending in KEYS_TO_IGNORE] if any(snake_case_ ): continue a = REMAINING_PATTERNS a = rename_state_dict_key(snake_case_, snake_case_ ) if new_k not in state_dict and k != "pegasus/embeddings/position_embeddings": raise ValueError(f"""could not find new key {new_k} in state dict. (converted from {k})""" ) if any(True if i in k else False for i in ['''dense''', '''query''', '''key''', '''value'''] ): a = v.T a = torch.from_numpy(snake_case_ ) if k != "pegasus/embeddings/position_embeddings": assert v.shape == state_dict[new_k].shape, f"""{new_k}, {k}, {v.shape}, {state_dict[new_k].shape}""" a = mapping['''model.embed_positions.weight'''] a = mapping.pop('''model.embed_positions.weight''' ) a , a = torch_model.load_state_dict(snake_case_, strict=snake_case_ ) a = [ k for k in missing if k not in [ '''final_logits_bias''', '''model.encoder.embed_tokens.weight''', '''model.decoder.embed_tokens.weight''', '''lm_head.weight''', ] ] assert unexpected_missing == [], f"""no matches found for the following torch keys {unexpected_missing}""" assert extra == [], f"""no matches found for the following tf keys {extra}""" return torch_model def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Dict: """simple docstring""" a = tf.train.list_variables(snake_case_ ) a = {} a = ['''global_step'''] for name, shape in tqdm(snake_case_, desc='''converting tf checkpoint to dict''' ): a = any(pat in name for pat in ignore_name ) if skip_key: continue a = tf.train.load_variable(snake_case_, snake_case_ ) a = array return tf_weights def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> int: """simple docstring""" a = get_tf_weights_as_numpy(snake_case_ ) a = convert_bigbird_pegasus(snake_case_, snake_case_ ) torch_model.save_pretrained(snake_case_ ) if __name__ == "__main__": UpperCamelCase__ : str = argparse.ArgumentParser() parser.add_argument("""--tf_ckpt_path""", type=str, help="""passed to tf.train.list_variables""") parser.add_argument("""--save_dir""", default=None, type=str, help="""Path to the output PyTorch model.""") UpperCamelCase__ : int = parser.parse_args() UpperCamelCase__ : Tuple = {} convert_bigbird_pegasus_ckpt_to_pytorch(args.tf_ckpt_path, args.save_dir, config_update=config_update)
330
1
import warnings from ...utils import logging from .image_processing_yolos import YolosImageProcessor UpperCamelCase__ : Tuple = logging.get_logger(__name__) class lowerCamelCase_ ( a_ ): def __init__( self : Union[str, Any] ,*__lowerCamelCase : Optional[int] ,**__lowerCamelCase : Optional[int] ): '''simple docstring''' warnings.warn( '''The class YolosFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please''' ''' use YolosImageProcessor instead.''' ,__lowerCamelCase ,) super().__init__(*__lowerCamelCase ,**__lowerCamelCase )
330
import re def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> str: """simple docstring""" if len(re.findall('''[ATCG]''', snake_case_ ) ) != len(snake_case_ ): raise ValueError('''Invalid Strand''' ) return dna.translate(dna.maketrans('''ATCG''', '''TAGC''' ) ) if __name__ == "__main__": import doctest doctest.testmod()
330
1
import argparse import csv import logging import os import random import numpy as np import torch from torch.utils.data import DataLoader, RandomSampler, SequentialSampler, TensorDataset from tqdm import tqdm, trange from transformers import ( CONFIG_NAME, WEIGHTS_NAME, AdamW, OpenAIGPTDoubleHeadsModel, OpenAIGPTTokenizer, get_linear_schedule_with_warmup, ) logging.basicConfig( format="""%(asctime)s - %(levelname)s - %(name)s - %(message)s""", datefmt="""%m/%d/%Y %H:%M:%S""", level=logging.INFO ) UpperCamelCase__ : Optional[int] = logging.getLogger(__name__) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> List[str]: """simple docstring""" a = np.argmax(snake_case_, axis=1 ) return np.sum(outputs == labels ) def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> int: """simple docstring""" with open(snake_case_, encoding='''utf_8''' ) as f: a = csv.reader(snake_case_ ) a = [] next(snake_case_ ) # skip the first line for line in tqdm(snake_case_ ): output.append((''' '''.join(line[1:5] ), line[5], line[6], int(line[-1] ) - 1) ) return output def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) -> Union[str, Any]: """simple docstring""" a = [] for dataset in encoded_datasets: a = len(snake_case_ ) a = np.zeros((n_batch, 2, input_len), dtype=np.intaa ) a = np.zeros((n_batch, 2), dtype=np.intaa ) a = np.full((n_batch, 2, input_len), fill_value=-1_0_0, dtype=np.intaa ) a = np.zeros((n_batch,), dtype=np.intaa ) for ( i, (story, conta, conta, mc_label), ) in enumerate(snake_case_ ): a = [start_token] + story[:cap_length] + [delimiter_token] + conta[:cap_length] + [clf_token] a = [start_token] + story[:cap_length] + [delimiter_token] + conta[:cap_length] + [clf_token] a = with_conta a = with_conta a = len(snake_case_ ) - 1 a = len(snake_case_ ) - 1 a = with_conta a = with_conta a = mc_label a = (input_ids, mc_token_ids, lm_labels, mc_labels) tensor_datasets.append(tuple(torch.tensor(snake_case_ ) for t in all_inputs ) ) return tensor_datasets def SCREAMING_SNAKE_CASE__ ( ) -> str: """simple docstring""" a = argparse.ArgumentParser() parser.add_argument('''--model_name''', type=snake_case_, default='''openai-gpt''', help='''pretrained model name''' ) parser.add_argument('''--do_train''', action='''store_true''', help='''Whether to run training.''' ) parser.add_argument('''--do_eval''', action='''store_true''', help='''Whether to run eval on the dev set.''' ) parser.add_argument( '''--output_dir''', default=snake_case_, type=snake_case_, required=snake_case_, help='''The output directory where the model predictions and checkpoints will be written.''', ) parser.add_argument('''--train_dataset''', type=snake_case_, default='''''' ) parser.add_argument('''--eval_dataset''', type=snake_case_, default='''''' ) parser.add_argument('''--seed''', type=snake_case_, default=4_2 ) parser.add_argument('''--num_train_epochs''', type=snake_case_, default=3 ) parser.add_argument('''--train_batch_size''', type=snake_case_, default=8 ) parser.add_argument('''--eval_batch_size''', type=snake_case_, default=1_6 ) parser.add_argument('''--adam_epsilon''', default=1e-8, type=snake_case_, help='''Epsilon for Adam optimizer.''' ) parser.add_argument('''--max_grad_norm''', type=snake_case_, default=1 ) parser.add_argument( '''--max_steps''', default=-1, type=snake_case_, help=( '''If > 0: set total number of training steps to perform. Override num_train_epochs.''' ), ) parser.add_argument( '''--gradient_accumulation_steps''', type=snake_case_, default=1, help='''Number of updates steps to accumulate before performing a backward/update pass.''', ) parser.add_argument('''--learning_rate''', type=snake_case_, default=6.25e-5 ) parser.add_argument('''--warmup_steps''', default=0, type=snake_case_, help='''Linear warmup over warmup_steps.''' ) parser.add_argument('''--lr_schedule''', type=snake_case_, default='''warmup_linear''' ) parser.add_argument('''--weight_decay''', type=snake_case_, default=0.01 ) parser.add_argument('''--lm_coef''', type=snake_case_, default=0.9 ) parser.add_argument('''--n_valid''', type=snake_case_, default=3_7_4 ) parser.add_argument('''--server_ip''', type=snake_case_, default='''''', help='''Can be used for distant debugging.''' ) parser.add_argument('''--server_port''', type=snake_case_, default='''''', help='''Can be used for distant debugging.''' ) a = parser.parse_args() print(snake_case_ ) if args.server_ip and args.server_port: # Distant debugging - see https://code.visualstudio.com/docs/python/debugging#_attach-to-a-local-script import ptvsd print('''Waiting for debugger attach''' ) ptvsd.enable_attach(address=(args.server_ip, args.server_port), redirect_output=snake_case_ ) ptvsd.wait_for_attach() random.seed(args.seed ) np.random.seed(args.seed ) torch.manual_seed(args.seed ) torch.cuda.manual_seed_all(args.seed ) a = torch.device('''cuda''' if torch.cuda.is_available() else '''cpu''' ) a = torch.cuda.device_count() logger.info('''device: {}, n_gpu {}'''.format(snake_case_, snake_case_ ) ) if not args.do_train and not args.do_eval: raise ValueError('''At least one of `do_train` or `do_eval` must be True.''' ) if not os.path.exists(args.output_dir ): os.makedirs(args.output_dir ) # Load tokenizer and model # This loading functions also add new tokens and embeddings called `special tokens` # These new embeddings will be fine-tuned on the RocStories dataset a = ['''_start_''', '''_delimiter_''', '''_classify_'''] a = OpenAIGPTTokenizer.from_pretrained(args.model_name ) tokenizer.add_tokens(snake_case_ ) a = tokenizer.convert_tokens_to_ids(snake_case_ ) a = OpenAIGPTDoubleHeadsModel.from_pretrained(args.model_name ) model.resize_token_embeddings(len(snake_case_ ) ) model.to(snake_case_ ) # Load and encode the datasets def tokenize_and_encode(snake_case_ ): if isinstance(snake_case_, snake_case_ ): return tokenizer.convert_tokens_to_ids(tokenizer.tokenize(snake_case_ ) ) elif isinstance(snake_case_, snake_case_ ): return obj return [tokenize_and_encode(snake_case_ ) for o in obj] logger.info('''Encoding dataset...''' ) a = load_rocstories_dataset(args.train_dataset ) a = load_rocstories_dataset(args.eval_dataset ) a = (train_dataset, eval_dataset) a = tokenize_and_encode(snake_case_ ) # Compute the max input length for the Transformer a = model.config.n_positions // 2 - 2 a = max( len(story[:max_length] ) + max(len(conta[:max_length] ), len(conta[:max_length] ) ) + 3 for dataset in encoded_datasets for story, conta, conta, _ in dataset ) a = min(snake_case_, model.config.n_positions ) # Max size of input for the pre-trained model # Prepare inputs tensors and dataloaders a = pre_process_datasets(snake_case_, snake_case_, snake_case_, *snake_case_ ) a , a = tensor_datasets[0], tensor_datasets[1] a = TensorDataset(*snake_case_ ) a = RandomSampler(snake_case_ ) a = DataLoader(snake_case_, sampler=snake_case_, batch_size=args.train_batch_size ) a = TensorDataset(*snake_case_ ) a = SequentialSampler(snake_case_ ) a = DataLoader(snake_case_, sampler=snake_case_, batch_size=args.eval_batch_size ) # Prepare optimizer if args.do_train: if args.max_steps > 0: a = args.max_steps a = args.max_steps // (len(snake_case_ ) // args.gradient_accumulation_steps) + 1 else: a = len(snake_case_ ) // args.gradient_accumulation_steps * args.num_train_epochs a = list(model.named_parameters() ) a = ['''bias''', '''LayerNorm.bias''', '''LayerNorm.weight'''] a = [ { '''params''': [p for n, p in param_optimizer if not any(nd in n for nd in no_decay )], '''weight_decay''': args.weight_decay, }, {'''params''': [p for n, p in param_optimizer if any(nd in n for nd in no_decay )], '''weight_decay''': 0.0}, ] a = AdamW(snake_case_, lr=args.learning_rate, eps=args.adam_epsilon ) a = get_linear_schedule_with_warmup( snake_case_, num_warmup_steps=args.warmup_steps, num_training_steps=snake_case_ ) if args.do_train: a , a , a = 0, 0, None model.train() for _ in trange(int(args.num_train_epochs ), desc='''Epoch''' ): a = 0 a = 0 a = tqdm(snake_case_, desc='''Training''' ) for step, batch in enumerate(snake_case_ ): a = tuple(t.to(snake_case_ ) for t in batch ) a , a , a , a = batch a = model(snake_case_, mc_token_ids=snake_case_, lm_labels=snake_case_, mc_labels=snake_case_ ) a = args.lm_coef * losses[0] + losses[1] loss.backward() optimizer.step() scheduler.step() optimizer.zero_grad() tr_loss += loss.item() a = ( loss.item() if exp_average_loss is None else 0.7 * exp_average_loss + 0.3 * loss.item() ) nb_tr_steps += 1 a = '''Training loss: {:.2e} lr: {:.2e}'''.format(snake_case_, scheduler.get_lr()[0] ) # Save a trained model if args.do_train: # Save a trained model, configuration and tokenizer a = model.module if hasattr(snake_case_, '''module''' ) else model # Only save the model itself # If we save using the predefined names, we can load using `from_pretrained` a = os.path.join(args.output_dir, snake_case_ ) a = os.path.join(args.output_dir, snake_case_ ) torch.save(model_to_save.state_dict(), snake_case_ ) model_to_save.config.to_json_file(snake_case_ ) tokenizer.save_vocabulary(args.output_dir ) # Load a trained model and vocabulary that you have fine-tuned a = OpenAIGPTDoubleHeadsModel.from_pretrained(args.output_dir ) a = OpenAIGPTTokenizer.from_pretrained(args.output_dir ) model.to(snake_case_ ) if args.do_eval: model.eval() a , a = 0, 0 a , a = 0, 0 for batch in tqdm(snake_case_, desc='''Evaluating''' ): a = tuple(t.to(snake_case_ ) for t in batch ) a , a , a , a = batch with torch.no_grad(): a , a , a , a = model( snake_case_, mc_token_ids=snake_case_, lm_labels=snake_case_, mc_labels=snake_case_ ) a = mc_logits.detach().cpu().numpy() a = mc_labels.to('''cpu''' ).numpy() a = accuracy(snake_case_, snake_case_ ) eval_loss += mc_loss.mean().item() eval_accuracy += tmp_eval_accuracy nb_eval_examples += input_ids.size(0 ) nb_eval_steps += 1 a = eval_loss / nb_eval_steps a = eval_accuracy / nb_eval_examples a = tr_loss / nb_tr_steps if args.do_train else None a = {'''eval_loss''': eval_loss, '''eval_accuracy''': eval_accuracy, '''train_loss''': train_loss} a = os.path.join(args.output_dir, '''eval_results.txt''' ) with open(snake_case_, '''w''' ) as writer: logger.info('''***** Eval results *****''' ) for key in sorted(result.keys() ): logger.info(''' %s = %s''', snake_case_, str(result[key] ) ) writer.write('''%s = %s\n''' % (key, str(result[key] )) ) if __name__ == "__main__": main()
330
from __future__ import annotations from collections.abc import Sequence from typing import Literal def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> str | Literal[False]: """simple docstring""" a = list(snake_case_ ) a = list(snake_case_ ) a = 0 for i in range(len(snake_case_ ) ): if lista[i] != lista[i]: count += 1 a = '''_''' if count > 1: return False else: return "".join(snake_case_ ) def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> list[str]: """simple docstring""" a = [] while True: a = ['''$'''] * len(snake_case_ ) a = [] for i in range(len(snake_case_ ) ): for j in range(i + 1, len(snake_case_ ) ): a = compare_string(binary[i], binary[j] ) if k is False: a = '''*''' a = '''*''' temp.append('''X''' ) for i in range(len(snake_case_ ) ): if checka[i] == "$": pi.append(binary[i] ) if len(snake_case_ ) == 0: return pi a = list(set(snake_case_ ) ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> list[str]: """simple docstring""" a = [] for minterm in minterms: a = '''''' for _ in range(snake_case_ ): a = str(minterm % 2 ) + string minterm //= 2 temp.append(snake_case_ ) return temp def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> bool: """simple docstring""" a = list(snake_case_ ) a = list(snake_case_ ) a = 0 for i in range(len(snake_case_ ) ): if lista[i] != lista[i]: count_n += 1 return count_n == count def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> list[str]: """simple docstring""" a = [] a = [0] * len(snake_case_ ) for i in range(len(chart[0] ) ): a = 0 a = -1 for j in range(len(snake_case_ ) ): if chart[j][i] == 1: count += 1 a = j if count == 1: a = 1 for i in range(len(snake_case_ ) ): if select[i] == 1: for j in range(len(chart[0] ) ): if chart[i][j] == 1: for k in range(len(snake_case_ ) ): a = 0 temp.append(prime_implicants[i] ) while True: a = 0 a = -1 a = 0 for i in range(len(snake_case_ ) ): a = chart[i].count(1 ) if count_n > max_n: a = count_n a = i if max_n == 0: return temp temp.append(prime_implicants[rem] ) for i in range(len(chart[0] ) ): if chart[rem][i] == 1: for j in range(len(snake_case_ ) ): a = 0 def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> list[list[int]]: """simple docstring""" a = [[0 for x in range(len(snake_case_ ) )] for x in range(len(snake_case_ ) )] for i in range(len(snake_case_ ) ): a = prime_implicants[i].count('''_''' ) for j in range(len(snake_case_ ) ): if is_for_table(prime_implicants[i], binary[j], snake_case_ ): a = 1 return chart def SCREAMING_SNAKE_CASE__ ( ) -> None: """simple docstring""" a = int(input('''Enter the no. of variables\n''' ) ) a = [ float(snake_case_ ) for x in input( '''Enter the decimal representation of Minterms \'Spaces Separated\'\n''' ).split() ] a = decimal_to_binary(snake_case_, snake_case_ ) a = check(snake_case_ ) print('''Prime Implicants are:''' ) print(snake_case_ ) a = prime_implicant_chart(snake_case_, snake_case_ ) a = selection(snake_case_, snake_case_ ) print('''Essential Prime Implicants are:''' ) print(snake_case_ ) if __name__ == "__main__": import doctest doctest.testmod() main()
330
1
from __future__ import annotations import os from collections.abc import Mapping UpperCamelCase__ : Any = tuple[int, int] class lowerCamelCase_ : def __init__( self : Optional[Any] ,__lowerCamelCase : set[int] ,__lowerCamelCase : Mapping[EdgeT, int] ): '''simple docstring''' a = vertices a = { (min(__lowerCamelCase ), max(__lowerCamelCase )): weight for edge, weight in edges.items() } def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : EdgeT ,__lowerCamelCase : int ): '''simple docstring''' self.vertices.add(edge[0] ) self.vertices.add(edge[1] ) a = weight def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' a = Graph({min(self.vertices )} ,{} ) a = 42 a = 42 a = 42 a = 42 while len(subgraph.vertices ) < len(self.vertices ): a = max(self.edges.values() ) + 1 for edge, weight in self.edges.items(): if (edge[0] in subgraph.vertices) ^ (edge[1] in subgraph.vertices): if weight < min_weight: a = edge a = weight subgraph.add_edge(__lowerCamelCase ,__lowerCamelCase ) return subgraph def SCREAMING_SNAKE_CASE__ ( snake_case_ = "p107_network.txt" ) -> int: """simple docstring""" a = os.path.abspath(os.path.dirname(snake_case_ ) ) a = os.path.join(snake_case_, snake_case_ ) a = {} a = 42 a = 42 a = 42 with open(snake_case_ ) as f: a = f.read().strip().split('''\n''' ) a = [line.split(''',''' ) for line in data] for edgea in range(1, len(snake_case_ ) ): for edgea in range(snake_case_ ): if adjaceny_matrix[edgea][edgea] != "-": a = int(adjaceny_matrix[edgea][edgea] ) a = Graph(set(range(len(snake_case_ ) ) ), snake_case_ ) a = graph.prims_algorithm() a = sum(graph.edges.values() ) a = sum(subgraph.edges.values() ) return initial_total - optimal_total if __name__ == "__main__": print(F"{solution() = }")
330
from typing import List, Union import numpy as np from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_torch_available(): import torch from ..models.auto.modeling_auto import MODEL_FOR_DEPTH_ESTIMATION_MAPPING UpperCamelCase__ : List[str] = logging.get_logger(__name__) @add_end_docstrings(a_ ) class lowerCamelCase_ ( a_ ): def __init__( self : int ,*__lowerCamelCase : str ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' super().__init__(*__lowerCamelCase ,**__lowerCamelCase ) requires_backends(self ,'''vision''' ) self.check_model_type(__lowerCamelCase ) def __call__( self : int ,__lowerCamelCase : Union[str, List[str], "Image.Image", List["Image.Image"]] ,**__lowerCamelCase : str ): '''simple docstring''' return super().__call__(__lowerCamelCase ,**__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Any ,**__lowerCamelCase : Dict ): '''simple docstring''' return {}, {}, {} def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = load_image(__lowerCamelCase ) a = image.size a = self.image_processor(images=__lowerCamelCase ,return_tensors=self.framework ) return model_inputs def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = self.model(**__lowerCamelCase ) return model_outputs def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = model_outputs.predicted_depth a = torch.nn.functional.interpolate( predicted_depth.unsqueeze(1 ) ,size=self.image_size[::-1] ,mode='''bicubic''' ,align_corners=__lowerCamelCase ) a = prediction.squeeze().cpu().numpy() a = (output * 2_55 / np.max(__lowerCamelCase )).astype('''uint8''' ) a = Image.fromarray(__lowerCamelCase ) a = {} a = predicted_depth a = depth return output_dict
330
1
from collections import defaultdict class lowerCamelCase_ : def __init__( self : str ,__lowerCamelCase : List[Any] ,__lowerCamelCase : int ): '''simple docstring''' a = total # total no of tasks (N) # DP table will have a dimension of (2^M)*N # initially all values are set to -1 a = [ [-1 for i in range(total + 1 )] for j in range(2 ** len(__lowerCamelCase ) ) ] a = defaultdict(__lowerCamelCase ) # stores the list of persons for each task # final_mask is used to check if all persons are included by setting all bits # to 1 a = (1 << len(__lowerCamelCase )) - 1 def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ,__lowerCamelCase : List[Any] ,__lowerCamelCase : List[str] ): '''simple docstring''' if mask == self.final_mask: return 1 # if not everyone gets the task and no more tasks are available, return 0 if task_no > self.total_tasks: return 0 # if case already considered if self.dp[mask][task_no] != -1: return self.dp[mask][task_no] # Number of ways when we don't this task in the arrangement a = self.count_ways_until(__lowerCamelCase ,task_no + 1 ) # now assign the tasks one by one to all possible persons and recursively # assign for the remaining tasks. if task_no in self.task: for p in self.task[task_no]: # if p is already given a task if mask & (1 << p): continue # assign this task to p and change the mask value. And recursively # assign tasks with the new mask value. total_ways_util += self.count_ways_until(mask | (1 << p) ,task_no + 1 ) # save the value. a = total_ways_util return self.dp[mask][task_no] def SCREAMING_SNAKE_CASE_ ( self : List[Any] ,__lowerCamelCase : List[Any] ): '''simple docstring''' for i in range(len(__lowerCamelCase ) ): for j in task_performed[i]: self.task[j].append(__lowerCamelCase ) # call the function to fill the DP table, final answer is stored in dp[0][1] return self.count_ways_until(0 ,1 ) if __name__ == "__main__": UpperCamelCase__ : Tuple = 5 # total no of tasks (the value of N) # the list of tasks that can be done by M persons. UpperCamelCase__ : int = [[1, 3, 4], [1, 2, 5], [3, 4]] print( AssignmentUsingBitmask(task_performed, total_tasks).count_no_of_ways( task_performed ) )
330
from dataclasses import dataclass, field from typing import ClassVar, Dict from ..features import Features, Value from .base import TaskTemplate @dataclass(frozen=a_ ) class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = field(default='language-modeling' , metadata={'include_in_asdict_even_if_is_default': True} ) SCREAMING_SNAKE_CASE_ = Features({'text': Value('string' )} ) SCREAMING_SNAKE_CASE_ = Features({} ) SCREAMING_SNAKE_CASE_ = "text" @property def SCREAMING_SNAKE_CASE_ ( self : int ): '''simple docstring''' return {self.text_column: "text"}
330
1
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 UpperCamelCase__ : Dict = """bert-base-cased""" UpperCamelCase__ : Dict = """google/pegasus-xsum""" UpperCamelCase__ : Optional[int] = [""" Sam ate lunch today.""", """Sams lunch ingredients."""] UpperCamelCase__ : Tuple = ["""A very interesting story about what I ate for lunch.""", """Avocado, celery, turkey, coffee"""] UpperCamelCase__ : str = """patrickvonplaten/t5-tiny-random""" UpperCamelCase__ : Any = """sshleifer/bart-tiny-random""" UpperCamelCase__ : Any = """sshleifer/tiny-mbart""" UpperCamelCase__ : int = """sshleifer/tiny-marian-en-de""" def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> Tuple: """simple docstring""" a = '''\n'''.join(snake_case_ ) Path(snake_case_ ).open('''w''' ).writelines(snake_case_ ) def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> int: """simple docstring""" for split in ["train", "val", "test"]: _dump_articles(os.path.join(snake_case_, f"""{split}.source""" ), snake_case_ ) _dump_articles(os.path.join(snake_case_, f"""{split}.target""" ), snake_case_ ) return tmp_dir class lowerCamelCase_ ( a_ ): @parameterized.expand( [ MBART_TINY, MARIAN_TINY, T5_TINY, BART_TINY, PEGASUS_XSUM, ] ,) @slow def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : str ): '''simple docstring''' a = AutoTokenizer.from_pretrained(__lowerCamelCase ) a = make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir() ) a = max(len(tokenizer.encode(__lowerCamelCase ) ) for a in ARTICLES ) a = max(len(tokenizer.encode(__lowerCamelCase ) ) for a in SUMMARIES ) a = 4 a = 8 assert max_len_target > max_src_len # Will be truncated assert max_len_source > max_src_len # Will be truncated a , a = '''ro_RO''', '''de_DE''' # ignored for all but mbart, but never causes error. a = SeqaSeqDataset( __lowerCamelCase ,data_dir=__lowerCamelCase ,type_path='''train''' ,max_source_length=__lowerCamelCase ,max_target_length=__lowerCamelCase ,src_lang=__lowerCamelCase ,tgt_lang=__lowerCamelCase ,) a = DataLoader(__lowerCamelCase ,batch_size=2 ,collate_fn=train_dataset.collate_fn ) for batch in dataloader: assert isinstance(__lowerCamelCase ,__lowerCamelCase ) 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 = 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 SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : int ): '''simple docstring''' a = AutoTokenizer.from_pretrained(__lowerCamelCase ) a = make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir() ) a = max(len(tokenizer.encode(__lowerCamelCase ) ) for a in ARTICLES ) a = max(len(tokenizer.encode(__lowerCamelCase ) ) for a in SUMMARIES ) a = 4 a = LegacySeqaSeqDataset( __lowerCamelCase ,data_dir=__lowerCamelCase ,type_path='''train''' ,max_source_length=20 ,max_target_length=__lowerCamelCase ,) a = DataLoader(__lowerCamelCase ,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 20 >= 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 SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' a = AutoTokenizer.from_pretrained('''facebook/mbart-large-cc25''' ) a = Path(make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir() ) ) a = tmp_dir.joinpath('''train.source''' ).open().readlines() a = Path(make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir() ) ) pack_data_dir(__lowerCamelCase ,__lowerCamelCase ,1_28 ,__lowerCamelCase ) a = {x.name for x in tmp_dir.iterdir()} a = {x.name for x in save_dir.iterdir()} a = 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(__lowerCamelCase ) < len(__lowerCamelCase ) assert len(__lowerCamelCase ) == 1 assert len(packed_examples[0] ) == sum(len(__lowerCamelCase ) for x in orig_examples ) assert orig_paths == new_paths @pytest.mark.skipif(not FAIRSEQ_AVAILABLE ,reason='''This test requires fairseq''' ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ): '''simple docstring''' if not FAIRSEQ_AVAILABLE: return a , a , a = self._get_dataset(max_len=64 ) a = 64 a = ds.make_dynamic_sampler(__lowerCamelCase ,required_batch_size_multiple=__lowerCamelCase ) a = [len(__lowerCamelCase ) for x in batch_sampler] assert len(set(__lowerCamelCase ) ) > 1 # it's not dynamic batch size if every batch is the same length assert sum(__lowerCamelCase ) == len(__lowerCamelCase ) # no dropped or added examples a = DataLoader(__lowerCamelCase ,batch_sampler=__lowerCamelCase ,collate_fn=ds.collate_fn ,num_workers=2 ) a = [] a = [] for batch in data_loader: a = batch['''input_ids'''].shape a = src_shape[0] assert bs % required_batch_size_multiple == 0 or bs < required_batch_size_multiple a = np.product(batch['''input_ids'''].shape ) num_src_per_batch.append(__lowerCamelCase ) if num_src_tokens > (max_tokens * 1.1): failures.append(__lowerCamelCase ) assert num_src_per_batch[0] == max(__lowerCamelCase ) if failures: raise AssertionError(F"""too many tokens in {len(__lowerCamelCase )} batches""" ) def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' a , a , a = self._get_dataset(max_len=5_12 ) a = 2 a = ds.make_sortish_sampler(__lowerCamelCase ,shuffle=__lowerCamelCase ) a = DataLoader(__lowerCamelCase ,batch_size=__lowerCamelCase ,collate_fn=ds.collate_fn ,num_workers=2 ) a = DataLoader(__lowerCamelCase ,batch_size=__lowerCamelCase ,collate_fn=ds.collate_fn ,num_workers=2 ,sampler=__lowerCamelCase ) a = tokenizer.pad_token_id def count_pad_tokens(__lowerCamelCase : Optional[Any] ,__lowerCamelCase : List[str]="input_ids" ): return [batch[k].eq(__lowerCamelCase ).sum().item() for batch in data_loader] assert sum(count_pad_tokens(__lowerCamelCase ,k='''labels''' ) ) < sum(count_pad_tokens(__lowerCamelCase ,k='''labels''' ) ) assert sum(count_pad_tokens(__lowerCamelCase ) ) < sum(count_pad_tokens(__lowerCamelCase ) ) assert len(__lowerCamelCase ) == len(__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : str=10_00 ,__lowerCamelCase : str=1_28 ): '''simple docstring''' if os.getenv('''USE_REAL_DATA''' ,__lowerCamelCase ): a = '''examples/seq2seq/wmt_en_ro''' a = max_len * 2 * 64 if not Path(__lowerCamelCase ).joinpath('''train.len''' ).exists(): save_len_file(__lowerCamelCase ,__lowerCamelCase ) else: a = '''examples/seq2seq/test_data/wmt_en_ro''' a = max_len * 4 save_len_file(__lowerCamelCase ,__lowerCamelCase ) a = AutoTokenizer.from_pretrained(__lowerCamelCase ) a = SeqaSeqDataset( __lowerCamelCase ,data_dir=__lowerCamelCase ,type_path='''train''' ,max_source_length=__lowerCamelCase ,max_target_length=__lowerCamelCase ,n_obs=__lowerCamelCase ,) return ds, max_tokens, tokenizer def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' a , a , a = self._get_dataset() a = set(DistributedSortishSampler(__lowerCamelCase ,2_56 ,num_replicas=2 ,rank=0 ,add_extra_examples=__lowerCamelCase ) ) a = set(DistributedSortishSampler(__lowerCamelCase ,2_56 ,num_replicas=2 ,rank=1 ,add_extra_examples=__lowerCamelCase ) ) assert idsa.intersection(__lowerCamelCase ) == set() @parameterized.expand( [ MBART_TINY, MARIAN_TINY, T5_TINY, BART_TINY, PEGASUS_XSUM, ] ,) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : Optional[Any] ): '''simple docstring''' a = AutoTokenizer.from_pretrained(__lowerCamelCase ,use_fast=__lowerCamelCase ) if tok_name == MBART_TINY: a = SeqaSeqDataset( __lowerCamelCase ,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 = train_dataset.dataset_kwargs assert "src_lang" in kwargs and "tgt_lang" in kwargs else: a = SeqaSeqDataset( __lowerCamelCase ,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 = train_dataset.dataset_kwargs assert "add_prefix_space" not in kwargs if tok_name != BART_TINY else "add_prefix_space" in kwargs assert len(__lowerCamelCase ) == 1 if tok_name == BART_TINY else len(__lowerCamelCase ) == 0
330
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__ : Union[str, Any] = logging.get_logger(__name__) UpperCamelCase__ : Union[str, Any] = { """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_ ): SCREAMING_SNAKE_CASE_ = 'yolos' def __init__( self : Union[str, Any] ,__lowerCamelCase : int=7_68 ,__lowerCamelCase : Dict=12 ,__lowerCamelCase : Union[str, Any]=12 ,__lowerCamelCase : List[Any]=30_72 ,__lowerCamelCase : int="gelu" ,__lowerCamelCase : int=0.0 ,__lowerCamelCase : str=0.0 ,__lowerCamelCase : Optional[Any]=0.02 ,__lowerCamelCase : int=1e-12 ,__lowerCamelCase : Any=[5_12, 8_64] ,__lowerCamelCase : Tuple=16 ,__lowerCamelCase : int=3 ,__lowerCamelCase : Tuple=True ,__lowerCamelCase : Optional[int]=1_00 ,__lowerCamelCase : List[Any]=True ,__lowerCamelCase : List[str]=False ,__lowerCamelCase : int=1 ,__lowerCamelCase : List[Any]=5 ,__lowerCamelCase : Optional[int]=2 ,__lowerCamelCase : int=5 ,__lowerCamelCase : str=2 ,__lowerCamelCase : Tuple=0.1 ,**__lowerCamelCase : List[Any] ,): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = hidden_size a = num_hidden_layers a = num_attention_heads a = intermediate_size a = hidden_act a = hidden_dropout_prob a = attention_probs_dropout_prob a = initializer_range a = layer_norm_eps a = image_size a = patch_size a = num_channels a = qkv_bias a = num_detection_tokens a = use_mid_position_embeddings a = auxiliary_loss # Hungarian matcher a = class_cost a = bbox_cost a = giou_cost # Loss coefficients a = bbox_loss_coefficient a = giou_loss_coefficient a = eos_coefficient class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = version.parse('1.11' ) @property def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' return OrderedDict( [ ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}), ] ) @property def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ): '''simple docstring''' return 1e-4 @property def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' return 12
330
1
from ...configuration_utils import PretrainedConfig UpperCamelCase__ : Tuple = { '''google/tapas-base-finetuned-sqa''': ( '''https://huggingface.co/google/tapas-base-finetuned-sqa/resolve/main/config.json''' ), '''google/tapas-base-finetuned-wtq''': ( '''https://huggingface.co/google/tapas-base-finetuned-wtq/resolve/main/config.json''' ), '''google/tapas-base-finetuned-wikisql-supervised''': ( '''https://huggingface.co/google/tapas-base-finetuned-wikisql-supervised/resolve/main/config.json''' ), '''google/tapas-base-finetuned-tabfact''': ( '''https://huggingface.co/google/tapas-base-finetuned-tabfact/resolve/main/config.json''' ), } class lowerCamelCase_ ( SCREAMING_SNAKE_CASE_ ): SCREAMING_SNAKE_CASE_ = 'tapas' def __init__( self : Optional[int] ,__lowerCamelCase : List[Any]=3_05_22 ,__lowerCamelCase : int=7_68 ,__lowerCamelCase : int=12 ,__lowerCamelCase : Tuple=12 ,__lowerCamelCase : List[Any]=30_72 ,__lowerCamelCase : str="gelu" ,__lowerCamelCase : Union[str, Any]=0.1 ,__lowerCamelCase : Union[str, Any]=0.1 ,__lowerCamelCase : Union[str, Any]=10_24 ,__lowerCamelCase : int=[3, 2_56, 2_56, 2, 2_56, 2_56, 10] ,__lowerCamelCase : Dict=0.02 ,__lowerCamelCase : int=1e-12 ,__lowerCamelCase : str=0 ,__lowerCamelCase : Dict=10.0 ,__lowerCamelCase : Tuple=0 ,__lowerCamelCase : Dict=1.0 ,__lowerCamelCase : str=None ,__lowerCamelCase : List[Any]=1.0 ,__lowerCamelCase : Union[str, Any]=False ,__lowerCamelCase : Any=None ,__lowerCamelCase : Optional[Any]=1.0 ,__lowerCamelCase : Dict=1.0 ,__lowerCamelCase : Dict=False ,__lowerCamelCase : List[str]=False ,__lowerCamelCase : List[Any]="ratio" ,__lowerCamelCase : Tuple=None ,__lowerCamelCase : str=None ,__lowerCamelCase : Dict=64 ,__lowerCamelCase : str=32 ,__lowerCamelCase : List[Any]=False ,__lowerCamelCase : int=True ,__lowerCamelCase : List[str]=False ,__lowerCamelCase : Any=False ,__lowerCamelCase : Dict=True ,__lowerCamelCase : Dict=False ,__lowerCamelCase : int=None ,__lowerCamelCase : Optional[int]=None ,**__lowerCamelCase : List[Any] ,): '''simple docstring''' super().__init__(pad_token_id=__a ,**__a ) # BERT hyperparameters (with updated max_position_embeddings and type_vocab_sizes) a = vocab_size a = hidden_size a = num_hidden_layers a = num_attention_heads a = hidden_act a = intermediate_size a = hidden_dropout_prob a = attention_probs_dropout_prob a = max_position_embeddings a = type_vocab_sizes a = initializer_range a = layer_norm_eps # Fine-tuning task hyperparameters a = positive_label_weight a = num_aggregation_labels a = aggregation_loss_weight a = use_answer_as_supervision a = answer_loss_importance a = use_normalized_answer_loss a = huber_loss_delta a = temperature a = aggregation_temperature a = use_gumbel_for_cells a = use_gumbel_for_aggregation a = average_approximation_function a = cell_selection_preference a = answer_loss_cutoff a = max_num_rows a = max_num_columns a = average_logits_per_cell a = select_one_column a = allow_empty_column_selection a = init_cell_selection_weights_to_zero a = reset_position_index_per_cell a = disable_per_token_loss # Aggregation hyperparameters a = aggregation_labels a = no_aggregation_label_index if isinstance(self.aggregation_labels ,__a ): a = {int(__a ): v for k, v in aggregation_labels.items()}
350
def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> int: """simple docstring""" a = '''''' for i in table: res += inp[i - 1] return res def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> int: """simple docstring""" return data[1:] + data[0] def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> List[str]: """simple docstring""" a = '''''' for i in range(len(snake_case_ ) ): if a[i] == b[i]: res += "0" else: res += "1" return res def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> Dict: """simple docstring""" a = int('''0b''' + data[0] + data[-1], 2 ) a = int('''0b''' + data[1:3], 2 ) return bin(s[row][col] )[2:] def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) -> Optional[int]: """simple docstring""" a = message[:4] a = message[4:] a = apply_table(snake_case_, snake_case_ ) a = xor(snake_case_, snake_case_ ) a = apply_sbox(snake_case_, temp[:4] ) # noqa: E741 a = apply_sbox(snake_case_, temp[4:] ) a = '''0''' * (2 - len(snake_case_ )) + l # noqa: E741 a = '''0''' * (2 - len(snake_case_ )) + r a = apply_table(l + r, snake_case_ ) a = xor(snake_case_, snake_case_ ) return temp + right if __name__ == "__main__": UpperCamelCase__ : int = input("""Enter 10 bit key: """) UpperCamelCase__ : Union[str, Any] = input("""Enter 8 bit message: """) UpperCamelCase__ : Dict = [6, 3, 7, 4, 8, 5, 10, 9] UpperCamelCase__ : Union[str, Any] = [3, 5, 2, 7, 4, 10, 1, 9, 8, 6] UpperCamelCase__ : Optional[int] = [2, 4, 3, 1] UpperCamelCase__ : List[Any] = [2, 6, 3, 1, 4, 8, 5, 7] UpperCamelCase__ : str = [4, 1, 3, 5, 7, 2, 8, 6] UpperCamelCase__ : List[Any] = [4, 1, 2, 3, 2, 3, 4, 1] UpperCamelCase__ : int = [[1, 0, 3, 2], [3, 2, 1, 0], [0, 2, 1, 3], [3, 1, 3, 2]] UpperCamelCase__ : Dict = [[0, 1, 2, 3], [2, 0, 1, 3], [3, 0, 1, 0], [2, 1, 0, 3]] # key generation UpperCamelCase__ : Optional[Any] = apply_table(key, paa_table) UpperCamelCase__ : str = temp[:5] UpperCamelCase__ : List[Any] = temp[5:] UpperCamelCase__ : Dict = left_shift(left) UpperCamelCase__ : Any = left_shift(right) UpperCamelCase__ : Optional[Any] = apply_table(left + right, pa_table) UpperCamelCase__ : List[str] = left_shift(left) UpperCamelCase__ : int = left_shift(right) UpperCamelCase__ : List[str] = left_shift(left) UpperCamelCase__ : Dict = left_shift(right) UpperCamelCase__ : List[str] = apply_table(left + right, pa_table) # encryption UpperCamelCase__ : Tuple = apply_table(message, IP) UpperCamelCase__ : Optional[Any] = function(expansion, sa, sa, keya, temp) UpperCamelCase__ : Optional[int] = temp[4:] + temp[:4] UpperCamelCase__ : Any = function(expansion, sa, sa, keya, temp) UpperCamelCase__ : Tuple = apply_table(temp, IP_inv) print("""Cipher text is:""", CT) # decryption UpperCamelCase__ : Union[str, Any] = apply_table(CT, IP) UpperCamelCase__ : List[str] = function(expansion, sa, sa, keya, temp) UpperCamelCase__ : Optional[Any] = temp[4:] + temp[:4] UpperCamelCase__ : Optional[int] = function(expansion, sa, sa, keya, temp) UpperCamelCase__ : Any = apply_table(temp, IP_inv) print("""Plain text after decypting is:""", PT)
330
0
import os import re import shutil import sys import tempfile import unittest import black UpperCamelCase__ : Union[str, Any] = os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))) sys.path.append(os.path.join(git_repo_path, """utils""")) import check_copies # noqa: E402 # This is the reference code that will be used in the tests. # If DDPMSchedulerOutput is changed in scheduling_ddpm.py, this code needs to be manually updated. UpperCamelCase__ : List[str] = """ \"\"\"\n Output class for the scheduler\'s step function output.\n\n Args:\n prev_sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)` for images):\n Computed sample (x_{t-1}) of previous timestep. `prev_sample` should be used as next model input in the\n denoising loop.\n pred_original_sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)` for images):\n The predicted denoised sample (x_{0}) based on the model output from the current timestep.\n `pred_original_sample` can be used to preview progress or for guidance.\n \"\"\"\n\n prev_sample: torch.FloatTensor\n pred_original_sample: Optional[torch.FloatTensor] = None\n""" class lowerCamelCase_ ( unittest.TestCase ): def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ): '''simple docstring''' a = tempfile.mkdtemp() os.makedirs(os.path.join(self.diffusers_dir ,'''schedulers/''' ) ) a = self.diffusers_dir shutil.copy( os.path.join(__A ,'''src/diffusers/schedulers/scheduling_ddpm.py''' ) ,os.path.join(self.diffusers_dir ,'''schedulers/scheduling_ddpm.py''' ) ,) def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' a = """src/diffusers""" shutil.rmtree(self.diffusers_dir ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : str ,__lowerCamelCase : Union[str, Any] ,__lowerCamelCase : Union[str, Any] ,__lowerCamelCase : int=None ): '''simple docstring''' a = comment + F"""\nclass {class_name}(nn.Module):\n""" + class_code if overwrite_result is not None: a = comment + F"""\nclass {class_name}(nn.Module):\n""" + overwrite_result a = black.Mode(target_versions={black.TargetVersion.PYaa} ,line_length=1_19 ) a = black.format_str(__A ,mode=__A ) a = os.path.join(self.diffusers_dir ,'''new_code.py''' ) with open(__A ,'''w''' ,newline='''\n''' ) as f: f.write(__A ) if overwrite_result is None: self.assertTrue(len(check_copies.is_copy_consistent(__A ) ) == 0 ) else: check_copies.is_copy_consistent(f.name ,overwrite=__A ) with open(__A ,'''r''' ) as f: self.assertTrue(f.read() ,__A ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ): '''simple docstring''' a = check_copies.find_code_in_diffusers('''schedulers.scheduling_ddpm.DDPMSchedulerOutput''' ) self.assertEqual(__A ,__A ) def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ): '''simple docstring''' self.check_copy_consistency( '''# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput''' ,'''DDPMSchedulerOutput''' ,REFERENCE_CODE + '''\n''' ,) # With no empty line at the end self.check_copy_consistency( '''# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput''' ,'''DDPMSchedulerOutput''' ,__A ,) # Copy consistency with rename self.check_copy_consistency( '''# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->Test''' ,'''TestSchedulerOutput''' ,re.sub('''DDPM''' ,'''Test''' ,__A ) ,) # Copy consistency with a really long name a = """TestClassWithAReallyLongNameBecauseSomePeopleLikeThatForSomeReason""" self.check_copy_consistency( F"""# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->{long_class_name}""" ,F"""{long_class_name}SchedulerOutput""" ,re.sub('''Bert''' ,__A ,__A ) ,) # Copy consistency with overwrite self.check_copy_consistency( '''# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->Test''' ,'''TestSchedulerOutput''' ,__A ,overwrite_result=re.sub('''DDPM''' ,'''Test''' ,__A ) ,)
351
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 lowerCamelCase_ ( unittest.TestCase ): @slow def SCREAMING_SNAKE_CASE_ ( self : Tuple ): '''simple docstring''' a = FlaxXLMRobertaModel.from_pretrained('''xlm-roberta-base''' ) a = AutoTokenizer.from_pretrained('''xlm-roberta-base''' ) a = '''The dog is cute and lives in the garden house''' a = jnp.array([tokenizer.encode(__lowerCamelCase )] ) a = (1, 12, 7_68) # batch_size, sequence_length, embedding_vector_dim a = jnp.array( [[-0.0_101, 0.1_218, -0.0_803, 0.0_801, 0.1_327, 0.0_776, -0.1_215, 0.2_383, 0.3_338, 0.3_106, 0.0_300, 0.0_252]] ) a = model(__lowerCamelCase )['''last_hidden_state'''] self.assertEqual(output.shape ,__lowerCamelCase ) # compare the actual values for a slice of last dim self.assertTrue(jnp.allclose(output[:, :, -1] ,__lowerCamelCase ,atol=1e-3 ) )
330
0
from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCamelCase__ : List[Any] = logging.get_logger(__name__) UpperCamelCase__ : List[str] = { # See all MEGATRON_BERT models at https://huggingface.co/models?filter=bert } class lowerCamelCase_ ( _UpperCAmelCase ): SCREAMING_SNAKE_CASE_ = "megatron-bert" def __init__( self : List[str] ,__lowerCamelCase : Union[str, Any]=2_90_56 ,__lowerCamelCase : Dict=10_24 ,__lowerCamelCase : int=24 ,__lowerCamelCase : Tuple=16 ,__lowerCamelCase : Optional[int]=40_96 ,__lowerCamelCase : List[str]="gelu" ,__lowerCamelCase : List[str]=0.1 ,__lowerCamelCase : str=0.1 ,__lowerCamelCase : Tuple=5_12 ,__lowerCamelCase : Optional[Any]=2 ,__lowerCamelCase : Any=0.02 ,__lowerCamelCase : Dict=1e-12 ,__lowerCamelCase : Optional[Any]=0 ,__lowerCamelCase : Optional[int]="absolute" ,__lowerCamelCase : Any=True ,**__lowerCamelCase : List[str] ,): '''simple docstring''' super().__init__(pad_token_id=_UpperCAmelCase ,**_UpperCAmelCase ) a = vocab_size a = hidden_size a = num_hidden_layers a = num_attention_heads a = hidden_act a = intermediate_size a = hidden_dropout_prob a = attention_probs_dropout_prob a = max_position_embeddings a = type_vocab_size a = initializer_range a = layer_norm_eps a = position_embedding_type a = use_cache
352
import argparse import os # New Code # 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 import find_executable_batch_size ######################################################################## # This is a fully working simple example to use Accelerate, # specifically showcasing how to ensure out-of-memory errors never # interrupt training, and builds off the `nlp_example.py` script. # # 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) # # New additions from the base script can be found quickly by # looking for the # New Code # tags # # 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 # ######################################################################## UpperCamelCase__ : Union[str, Any] = 16 UpperCamelCase__ : Dict = 32 def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ = 1_6 ) -> Tuple: """simple docstring""" a = AutoTokenizer.from_pretrained('''bert-base-cased''' ) a = load_dataset('''glue''', '''mrpc''' ) def tokenize_function(snake_case_ ): # max_length=None => use the model max length (it's actually the default) a = 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(): a = 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 a = tokenized_datasets.rename_column('''label''', '''labels''' ) def collate_fn(snake_case_ ): # On TPU it's best to pad everything to the same length or training will be very slow. a = 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": a = 1_6 elif accelerator.mixed_precision != "no": a = 8 else: a = None return tokenizer.pad( snake_case_, padding='''longest''', max_length=snake_case_, pad_to_multiple_of=snake_case_, return_tensors='''pt''', ) # Instantiate dataloaders. a = DataLoader( tokenized_datasets['''train'''], shuffle=snake_case_, collate_fn=snake_case_, batch_size=snake_case_ ) a = 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 UpperCamelCase__ : int = mocked_dataloaders # noqa: F811 def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> List[Any]: """simple docstring""" if os.environ.get('''TESTING_MOCKED_DATALOADERS''', snake_case_ ) == "1": a = 2 # Initialize accelerator a = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision ) # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs a = config['''lr'''] a = int(config['''num_epochs'''] ) a = int(config['''seed'''] ) a = int(config['''batch_size'''] ) a = evaluate.load('''glue''', '''mrpc''' ) # New Code # # We now can define an inner training loop function. It should take a batch size as the only parameter, # and build the dataloaders in there. # It also gets our decorator @find_executable_batch_size(starting_batch_size=snake_case_ ) def inner_training_loop(snake_case_ ): # And now just move everything below under this function # We need to bring in the Accelerator object from earlier nonlocal accelerator # And reset all of its attributes that could hold onto any memory: accelerator.free_memory() # Then we can declare the model, optimizer, and everything else: set_seed(snake_case_ ) # Instantiate the model (we build the model here so that the seed also control new weights initialization) a = 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). a = model.to(accelerator.device ) # Instantiate optimizer a = AdamW(params=model.parameters(), lr=snake_case_ ) a , a = get_dataloaders(snake_case_, snake_case_ ) # Instantiate scheduler a = 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. a , a , a , a , a = 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() 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 ) a = model(**snake_case_ ) a = outputs.loss accelerator.backward(snake_case_ ) optimizer.step() lr_scheduler.step() optimizer.zero_grad() 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(): a = model(**snake_case_ ) a = outputs.logits.argmax(dim=-1 ) a , a = accelerator.gather_for_metrics((predictions, batch['''labels''']) ) metric.add_batch( predictions=snake_case_, references=snake_case_, ) a = metric.compute() # Use accelerator.print to print only on the main process. accelerator.print(f"""epoch {epoch}:""", snake_case_ ) # New Code # # And call it at the end with no arguments # Note: You could also refactor this outside of your training loop function inner_training_loop() def SCREAMING_SNAKE_CASE__ ( ) -> Tuple: """simple docstring""" a = 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.''', ) parser.add_argument('''--cpu''', action='''store_true''', help='''If passed, will train on the CPU.''' ) a = parser.parse_args() a = {'''lr''': 2e-5, '''num_epochs''': 3, '''seed''': 4_2, '''batch_size''': 1_6} training_function(snake_case_, snake_case_ ) if __name__ == "__main__": main()
330
0
import argparse import json import os import fairseq import torch from fairseq.data import Dictionary # Register SEW's fairseq modules from sew_asapp import tasks # noqa: F401 from transformers import ( SEWConfig, SEWForCTC, SEWModel, WavaVecaCTCTokenizer, WavaVecaFeatureExtractor, WavaVecaProcessor, logging, ) logging.set_verbosity_info() UpperCamelCase__ : Union[str, Any] = logging.get_logger(__name__) UpperCamelCase__ : str = { """post_extract_proj""": """feature_projection""", """encoder.pos_conv.0""": """encoder.pos_conv_embed.conv""", """self_attn.k_proj""": """encoder.layers.*.attention.k_proj""", """self_attn.v_proj""": """encoder.layers.*.attention.v_proj""", """self_attn.q_proj""": """encoder.layers.*.attention.q_proj""", """self_attn.out_proj""": """encoder.layers.*.attention.out_proj""", """self_attn_layer_norm""": """encoder.layers.*.layer_norm""", """fc1""": """encoder.layers.*.feed_forward.intermediate_dense""", """fc2""": """encoder.layers.*.feed_forward.output_dense""", """final_layer_norm""": """encoder.layers.*.final_layer_norm""", """encoder.upsample.0""": """encoder.upsample.projection""", """encoder.layer_norm""": """encoder.layer_norm""", """w2v_model.layer_norm""": """layer_norm""", """w2v_encoder.proj""": """lm_head""", """mask_emb""": """masked_spec_embed""", } def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) -> Union[str, Any]: """simple docstring""" for attribute in key.split('''.''' ): a = getattr(__lowerCAmelCase, __lowerCAmelCase ) if weight_type is not None: a = getattr(__lowerCAmelCase, __lowerCAmelCase ).shape else: a = 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": a = value elif weight_type == "weight_g": a = value elif weight_type == "weight_v": a = value elif weight_type == "bias": a = value else: a = value logger.info(f"""{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.""" ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> int: """simple docstring""" a = [] a = fairseq_model.state_dict() a = hf_model.sew.feature_extractor if is_finetuned else hf_model.feature_extractor for name, value in fairseq_dict.items(): a = False if "conv_layers" in name: load_conv_layer( __lowerCAmelCase, __lowerCAmelCase, __lowerCAmelCase, __lowerCAmelCase, hf_model.config.feat_extract_norm == '''group''', ) a = True else: for key, mapped_key in MAPPING.items(): a = '''sew.''' + mapped_key if (is_finetuned and mapped_key != '''lm_head''') else mapped_key if key in name or key.split('''w2v_model.''' )[-1] == name.split('''.''' )[0]: a = True if "*" in mapped_key: a = name.split(__lowerCAmelCase )[0].split('''.''' )[-2] a = mapped_key.replace('''*''', __lowerCAmelCase ) if "weight_g" in name: a = '''weight_g''' elif "weight_v" in name: a = '''weight_v''' elif "weight" in name: a = '''weight''' elif "bias" in name: a = '''bias''' else: a = None set_recursively(__lowerCAmelCase, __lowerCAmelCase, __lowerCAmelCase, __lowerCAmelCase, __lowerCAmelCase ) continue if not is_used: unused_weights.append(__lowerCAmelCase ) logger.warning(f"""Unused weights: {unused_weights}""" ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) -> List[str]: """simple docstring""" a = full_name.split('''conv_layers.''' )[-1] a = name.split('''.''' ) a = int(items[0] ) a = 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.""" ) a = 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.""" ) a = 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." ) a = 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.""" ) a = value logger.info(f"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.""" ) else: unused_weights.append(__lowerCAmelCase ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> List[str]: """simple docstring""" a = SEWConfig() if is_finetuned: a = model.wav_encoder.wav_model.cfg else: a = model.cfg a = fs_config.conv_bias a = eval(fs_config.conv_feature_layers ) a = [x[0] for x in conv_layers] a = [x[1] for x in conv_layers] a = [x[2] for x in conv_layers] a = '''gelu''' a = '''layer''' if fs_config.extractor_mode == '''layer_norm''' else '''group''' a = 0.0 a = fs_config.activation_fn.name a = fs_config.encoder_embed_dim a = 0.02 a = fs_config.encoder_ffn_embed_dim a = 1e-5 a = fs_config.encoder_layerdrop a = fs_config.encoder_attention_heads a = fs_config.conv_pos_groups a = fs_config.conv_pos a = len(__lowerCAmelCase ) a = fs_config.encoder_layers a = fs_config.squeeze_factor # take care of any params that are overridden by the Wav2VecCtc model if is_finetuned: a = model.cfg a = fs_config.final_dropout a = fs_config.layerdrop a = fs_config.activation_dropout a = fs_config.mask_prob > 0 or fs_config.mask_channel_prob > 0 a = fs_config.attention_dropout a = fs_config.dropout_input a = fs_config.dropout a = fs_config.mask_channel_length a = fs_config.mask_channel_prob a = fs_config.mask_length a = fs_config.mask_prob a = '''Wav2Vec2FeatureExtractor''' a = '''Wav2Vec2CTCTokenizer''' return config @torch.no_grad() def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_=None, snake_case_=None, snake_case_=True ) -> Any: """simple docstring""" if is_finetuned: a , a , a = fairseq.checkpoint_utils.load_model_ensemble_and_task( [checkpoint_path], arg_overrides={'''data''': '''/'''.join(dict_path.split('''/''' )[:-1] )} ) else: a , a , a = fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path] ) if config_path is not None: a = SEWConfig.from_pretrained(__lowerCAmelCase ) else: a = convert_config(model[0], __lowerCAmelCase ) a = model[0].eval() a = True if config.feat_extract_norm == '''layer''' else False a = WavaVecaFeatureExtractor( feature_size=1, sampling_rate=1_6_0_0_0, padding_value=0, do_normalize=__lowerCAmelCase, return_attention_mask=__lowerCAmelCase, ) if is_finetuned: if dict_path: a = Dictionary.load(__lowerCAmelCase ) # important change bos & pad token id since CTC symbol is <pad> and # not <s> as in fairseq a = target_dict.pad_index a = target_dict.bos_index a = target_dict.pad_index a = target_dict.bos_index a = target_dict.eos_index a = len(target_dict.symbols ) a = os.path.join(__lowerCAmelCase, '''vocab.json''' ) if not os.path.isdir(__lowerCAmelCase ): logger.error('''--pytorch_dump_folder_path ({}) should be a directory'''.format(__lowerCAmelCase ) ) return os.makedirs(__lowerCAmelCase, exist_ok=__lowerCAmelCase ) with open(__lowerCAmelCase, '''w''', encoding='''utf-8''' ) as vocab_handle: json.dump(target_dict.indices, __lowerCAmelCase ) a = WavaVecaCTCTokenizer( __lowerCAmelCase, unk_token=target_dict.unk_word, pad_token=target_dict.pad_word, bos_token=target_dict.bos_word, eos_token=target_dict.eos_word, word_delimiter_token='''|''', do_lower_case=__lowerCAmelCase, ) a = WavaVecaProcessor(feature_extractor=__lowerCAmelCase, tokenizer=__lowerCAmelCase ) processor.save_pretrained(__lowerCAmelCase ) a = SEWForCTC(__lowerCAmelCase ) else: a = SEWModel(__lowerCAmelCase ) feature_extractor.save_pretrained(__lowerCAmelCase ) recursively_load_weights(__lowerCAmelCase, __lowerCAmelCase, __lowerCAmelCase ) hf_model.save_pretrained(__lowerCAmelCase ) if __name__ == "__main__": UpperCamelCase__ : Any = argparse.ArgumentParser() parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""") parser.add_argument("""--checkpoint_path""", default=None, type=str, help="""Path to fairseq checkpoint""") parser.add_argument("""--dict_path""", default=None, type=str, help="""Path to dict of fine-tuned model""") parser.add_argument("""--config_path""", default=None, type=str, help="""Path to hf config.json of model to convert""") parser.add_argument( """--is_finetuned""", action="""store_true""", help="""Whether the model to convert is a fine-tuned model or not""" ) UpperCamelCase__ : Dict = parser.parse_args() convert_sew_checkpoint( args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, args.is_finetuned )
353
import argparse import fairseq import torch from transformers import UniSpeechSatConfig, UniSpeechSatForCTC, UniSpeechSatForPreTraining, logging logging.set_verbosity_info() UpperCamelCase__ : Optional[int] = logging.get_logger(__name__) UpperCamelCase__ : str = { """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""", """encoder.layer_norm_for_extract""": """layer_norm_for_extract""", """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""", """label_embs_concat""": """label_embeddings_concat""", """mask_emb""": """masked_spec_embed""", """spk_proj""": """speaker_proj""", } UpperCamelCase__ : Optional[Any] = [ """lm_head""", """quantizer.weight_proj""", """quantizer.codevectors""", """project_q""", """project_hid""", """label_embeddings_concat""", """speaker_proj""", """layer_norm_for_extract""", ] def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) -> List[Any]: """simple docstring""" for attribute in key.split('''.''' ): a = getattr(snake_case_, snake_case_ ) if weight_type is not None: a = getattr(snake_case_, snake_case_ ).shape else: a = 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 = value elif weight_type == "weight_g": a = value elif weight_type == "weight_v": a = value elif weight_type == "bias": a = value else: a = value logger.info(f"""{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.""" ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> Union[str, Any]: """simple docstring""" a = [] a = fairseq_model.state_dict() a = hf_model.unispeech_sat.feature_extractor for name, value in fairseq_dict.items(): a = False if "conv_layers" in name: load_conv_layer( snake_case_, snake_case_, snake_case_, snake_case_, hf_model.config.feat_extract_norm == '''group''', ) a = True else: for key, mapped_key in MAPPING.items(): a = '''unispeech_sat.''' + 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]: if "layer_norm_for_extract" in name and (".".join(name.split('''.''' )[:-1] ) != key): # special case since naming is very similar continue a = True if "*" in mapped_key: a = name.split(snake_case_ )[0].split('''.''' )[-2] a = mapped_key.replace('''*''', snake_case_ ) if "weight_g" in name: a = '''weight_g''' elif "weight_v" in name: a = '''weight_v''' elif "bias" in name: a = '''bias''' elif "weight" in name: # TODO: don't match quantizer.weight_proj a = '''weight''' else: a = None set_recursively(snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) continue if not is_used: unused_weights.append(snake_case_ ) logger.warning(f"""Unused weights: {unused_weights}""" ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) -> Union[str, Any]: """simple docstring""" a = full_name.split('''conv_layers.''' )[-1] a = name.split('''.''' ) a = int(items[0] ) a = 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 = 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 = 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[layer_id].layer_norm.bias.data.shape} was found.""" ) a = 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[layer_id].layer_norm.weight.data.shape} was found.""" ) a = value logger.info(f"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.""" ) else: unused_weights.append(snake_case_ ) @torch.no_grad() def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_=None, snake_case_=None, snake_case_=True ) -> Union[str, Any]: """simple docstring""" if config_path is not None: a = UniSpeechSatConfig.from_pretrained(snake_case_ ) else: a = UniSpeechSatConfig() a = '''''' if is_finetuned: a = UniSpeechSatForCTC(snake_case_ ) else: a = UniSpeechSatForPreTraining(snake_case_ ) a , a , a = fairseq.checkpoint_utils.load_model_ensemble_and_task( [checkpoint_path], arg_overrides={'''data''': '''/'''.join(dict_path.split('''/''' )[:-1] )} ) a = model[0].eval() recursively_load_weights(snake_case_, snake_case_ ) hf_wavavec.save_pretrained(snake_case_ ) if __name__ == "__main__": UpperCamelCase__ : Optional[int] = argparse.ArgumentParser() parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""") parser.add_argument("""--checkpoint_path""", default=None, type=str, help="""Path to fairseq checkpoint""") parser.add_argument("""--dict_path""", default=None, type=str, help="""Path to dict of fine-tuned model""") parser.add_argument("""--config_path""", default=None, type=str, help="""Path to hf config.json of model to convert""") parser.add_argument( """--not_finetuned""", action="""store_true""", help="""Whether the model to convert is a fine-tuned model or not""" ) UpperCamelCase__ : int = parser.parse_args() convert_unispeech_sat_checkpoint( args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned )
330
0
from argparse import ArgumentParser, Namespace from ..utils import logging from . import BaseTransformersCLICommand def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Union[str, Any]: """simple docstring""" return ConvertCommand( args.model_type, args.tf_checkpoint, args.pytorch_dump_output, args.config, args.finetuning_task_name ) UpperCamelCase__ : Dict = """ transformers can only be used from the commandline to convert TensorFlow models in PyTorch, In that case, it requires TensorFlow to be installed. Please see https://www.tensorflow.org/install/ for installation instructions. """ class lowerCamelCase_ ( a__ ): @staticmethod def SCREAMING_SNAKE_CASE_ ( __lowerCamelCase : ArgumentParser ): '''simple docstring''' a = parser.add_parser( '''convert''' ,help='''CLI tool to run convert model from original author checkpoints to Transformers PyTorch checkpoints.''' ,) train_parser.add_argument('''--model_type''' ,type=_lowerCamelCase ,required=_lowerCamelCase ,help='''Model\'s type.''' ) train_parser.add_argument( '''--tf_checkpoint''' ,type=_lowerCamelCase ,required=_lowerCamelCase ,help='''TensorFlow checkpoint path or folder.''' ) train_parser.add_argument( '''--pytorch_dump_output''' ,type=_lowerCamelCase ,required=_lowerCamelCase ,help='''Path to the PyTorch saved model output.''' ) train_parser.add_argument('''--config''' ,type=_lowerCamelCase ,default='''''' ,help='''Configuration file path or folder.''' ) train_parser.add_argument( '''--finetuning_task_name''' ,type=_lowerCamelCase ,default=_lowerCamelCase ,help='''Optional fine-tuning task name if the TF model was a finetuned model.''' ,) train_parser.set_defaults(func=_lowerCamelCase ) def __init__( self : Dict ,__lowerCamelCase : str ,__lowerCamelCase : str ,__lowerCamelCase : str ,__lowerCamelCase : str ,__lowerCamelCase : str ,*__lowerCamelCase : Optional[Any] ,): '''simple docstring''' a = logging.get_logger('''transformers-cli/converting''' ) self._logger.info(F"""Loading model {model_type}""" ) a = model_type a = tf_checkpoint a = pytorch_dump_output a = config a = finetuning_task_name def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' if self._model_type == "albert": try: from ..models.albert.convert_albert_original_tf_checkpoint_to_pytorch import ( convert_tf_checkpoint_to_pytorch, ) except ImportError: raise ImportError(_lowerCamelCase ) convert_tf_checkpoint_to_pytorch(self._tf_checkpoint ,self._config ,self._pytorch_dump_output ) elif self._model_type == "bert": try: from ..models.bert.convert_bert_original_tf_checkpoint_to_pytorch import ( convert_tf_checkpoint_to_pytorch, ) except ImportError: raise ImportError(_lowerCamelCase ) convert_tf_checkpoint_to_pytorch(self._tf_checkpoint ,self._config ,self._pytorch_dump_output ) elif self._model_type == "funnel": try: from ..models.funnel.convert_funnel_original_tf_checkpoint_to_pytorch import ( convert_tf_checkpoint_to_pytorch, ) except ImportError: raise ImportError(_lowerCamelCase ) convert_tf_checkpoint_to_pytorch(self._tf_checkpoint ,self._config ,self._pytorch_dump_output ) elif self._model_type == "t5": try: from ..models.ta.convert_ta_original_tf_checkpoint_to_pytorch import convert_tf_checkpoint_to_pytorch except ImportError: raise ImportError(_lowerCamelCase ) convert_tf_checkpoint_to_pytorch(self._tf_checkpoint ,self._config ,self._pytorch_dump_output ) elif self._model_type == "gpt": from ..models.openai.convert_openai_original_tf_checkpoint_to_pytorch import ( convert_openai_checkpoint_to_pytorch, ) convert_openai_checkpoint_to_pytorch(self._tf_checkpoint ,self._config ,self._pytorch_dump_output ) elif self._model_type == "transfo_xl": try: from ..models.transfo_xl.convert_transfo_xl_original_tf_checkpoint_to_pytorch import ( convert_transfo_xl_checkpoint_to_pytorch, ) except ImportError: raise ImportError(_lowerCamelCase ) if "ckpt" in self._tf_checkpoint.lower(): a = self._tf_checkpoint a = '''''' else: a = self._tf_checkpoint a = '''''' convert_transfo_xl_checkpoint_to_pytorch( _lowerCamelCase ,self._config ,self._pytorch_dump_output ,_lowerCamelCase ) elif self._model_type == "gpt2": try: from ..models.gpta.convert_gpta_original_tf_checkpoint_to_pytorch import ( convert_gpta_checkpoint_to_pytorch, ) except ImportError: raise ImportError(_lowerCamelCase ) convert_gpta_checkpoint_to_pytorch(self._tf_checkpoint ,self._config ,self._pytorch_dump_output ) elif self._model_type == "xlnet": try: from ..models.xlnet.convert_xlnet_original_tf_checkpoint_to_pytorch import ( convert_xlnet_checkpoint_to_pytorch, ) except ImportError: raise ImportError(_lowerCamelCase ) convert_xlnet_checkpoint_to_pytorch( self._tf_checkpoint ,self._config ,self._pytorch_dump_output ,self._finetuning_task_name ) elif self._model_type == "xlm": from ..models.xlm.convert_xlm_original_pytorch_checkpoint_to_pytorch import ( convert_xlm_checkpoint_to_pytorch, ) convert_xlm_checkpoint_to_pytorch(self._tf_checkpoint ,self._pytorch_dump_output ) elif self._model_type == "lxmert": from ..models.lxmert.convert_lxmert_original_tf_checkpoint_to_pytorch import ( convert_lxmert_checkpoint_to_pytorch, ) convert_lxmert_checkpoint_to_pytorch(self._tf_checkpoint ,self._pytorch_dump_output ) elif self._model_type == "rembert": from ..models.rembert.convert_rembert_tf_checkpoint_to_pytorch import ( convert_rembert_tf_checkpoint_to_pytorch, ) convert_rembert_tf_checkpoint_to_pytorch(self._tf_checkpoint ,self._config ,self._pytorch_dump_output ) else: raise ValueError( '''--model_type should be selected in the list [bert, gpt, gpt2, t5, transfo_xl, xlnet, xlm, lxmert]''' )
354
import pytest from datasets import inspect_metric, list_metrics, load_metric @pytest.fixture def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> List[str]: """simple docstring""" monkeypatch.setattr('''datasets.utils.deprecation_utils._emitted_deprecation_warnings''', set() ) @pytest.fixture def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Optional[int]: """simple docstring""" class lowerCamelCase_ : def __init__( self : Dict ,__lowerCamelCase : List[str] ): '''simple docstring''' a = metric_id class lowerCamelCase_ : SCREAMING_SNAKE_CASE_ = [MetricMock(a_ ) for metric_id in ['accuracy', 'mse', 'precision', 'codeparrot/apps_metric']] def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' return self._metrics monkeypatch.setattr('''datasets.inspect.huggingface_hub''', HfhMock() ) @pytest.mark.parametrize( '''func, args''', [(load_metric, ('''metrics/mse''',)), (list_metrics, ()), (inspect_metric, ('''metrics/mse''', '''tmp_path'''))] ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) -> Tuple: """simple docstring""" if "tmp_path" in args: a = tuple(arg if arg != '''tmp_path''' else tmp_path for arg in args ) with pytest.warns(snake_case_, match='''https://huggingface.co/docs/evaluate''' ): func(*snake_case_ )
330
0
"""simple docstring""" from __future__ import annotations def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_, ) -> Optional[int]: """simple docstring""" a = len(__a ) # If row is equal to the size of the board it means there are a queen in each row in # the current board (possible_board) if row == n: # We convert the variable possible_board that looks like this: [1, 3, 0, 2] to # this: ['. Q . . ', '. . . Q ', 'Q . . . ', '. . Q . '] boards.append(['''. ''' * i + '''Q ''' + '''. ''' * (n - 1 - i) for i in possible_board] ) return # We iterate each column in the row to find all possible results in each row for col in range(__a ): # We apply that we learned previously. First we check that in the current board # (possible_board) there are not other same value because if there is it means # that there are a collision in vertical. Then we apply the two formulas we # learned before: # # 45º: y - x = b or 45: row - col = b # 135º: y + x = b or row + col = b. # # And we verify if the results of this two formulas not exist in their variables # respectively. (diagonal_right_collisions, diagonal_left_collisions) # # If any or these are True it means there is a collision so we continue to the # next value in the for loop. if ( col in possible_board or row - col in diagonal_right_collisions or row + col in diagonal_left_collisions ): continue # If it is False we call dfs function again and we update the inputs depth_first_search( [*possible_board, col], [*diagonal_right_collisions, row - col], [*diagonal_left_collisions, row + col], __a, __a, ) def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Dict: """simple docstring""" a = [] depth_first_search([], [], [], __a, __a ) # Print all the boards for board in boards: for column in board: print(__a ) print('''''' ) print(len(__a ), '''solutions were found.''' ) if __name__ == "__main__": import doctest doctest.testmod() n_queens_solution(4)
355
from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCamelCase__ : str = logging.get_logger(__name__) UpperCamelCase__ : Optional[int] = { """studio-ousia/luke-base""": """https://huggingface.co/studio-ousia/luke-base/resolve/main/config.json""", """studio-ousia/luke-large""": """https://huggingface.co/studio-ousia/luke-large/resolve/main/config.json""", } class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = 'luke' def __init__( self : Dict ,__lowerCamelCase : Optional[Any]=5_02_67 ,__lowerCamelCase : str=50_00_00 ,__lowerCamelCase : Any=7_68 ,__lowerCamelCase : int=2_56 ,__lowerCamelCase : Optional[int]=12 ,__lowerCamelCase : Tuple=12 ,__lowerCamelCase : Any=30_72 ,__lowerCamelCase : Any="gelu" ,__lowerCamelCase : Any=0.1 ,__lowerCamelCase : Tuple=0.1 ,__lowerCamelCase : Tuple=5_12 ,__lowerCamelCase : int=2 ,__lowerCamelCase : Optional[int]=0.02 ,__lowerCamelCase : List[Any]=1e-12 ,__lowerCamelCase : Dict=True ,__lowerCamelCase : Tuple=None ,__lowerCamelCase : Any=1 ,__lowerCamelCase : Dict=0 ,__lowerCamelCase : Any=2 ,**__lowerCamelCase : str ,): '''simple docstring''' super().__init__(pad_token_id=__lowerCamelCase ,bos_token_id=__lowerCamelCase ,eos_token_id=__lowerCamelCase ,**__lowerCamelCase ) a = vocab_size a = entity_vocab_size a = hidden_size a = entity_emb_size a = num_hidden_layers a = num_attention_heads a = hidden_act a = intermediate_size a = hidden_dropout_prob a = attention_probs_dropout_prob a = max_position_embeddings a = type_vocab_size a = initializer_range a = layer_norm_eps a = use_entity_aware_attention a = classifier_dropout
330
0
import shutil import tempfile import unittest import numpy as np import pytest from transformers import is_speech_available, is_vision_available from transformers.testing_utils import require_torch if is_vision_available(): from transformers import TvltImageProcessor if is_speech_available(): from transformers import TvltFeatureExtractor from transformers import TvltProcessor @require_torch class lowerCamelCase_ ( unittest.TestCase ): def SCREAMING_SNAKE_CASE_ ( self : List[str] ): '''simple docstring''' a = '''ZinengTang/tvlt-base''' a = tempfile.mkdtemp() def SCREAMING_SNAKE_CASE_ ( self : Any ,**__lowerCamelCase : List[Any] ): '''simple docstring''' return TvltImageProcessor.from_pretrained(self.checkpoint ,**__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : List[Any] ,**__lowerCamelCase : int ): '''simple docstring''' return TvltFeatureExtractor.from_pretrained(self.checkpoint ,**__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' shutil.rmtree(self.tmpdirname ) def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' a = self.get_image_processor() a = self.get_feature_extractor() a = TvltProcessor(image_processor=__lowerCamelCase ,feature_extractor=__lowerCamelCase ) processor.save_pretrained(self.tmpdirname ) a = TvltProcessor.from_pretrained(self.tmpdirname ) self.assertIsInstance(processor.feature_extractor ,__lowerCamelCase ) self.assertIsInstance(processor.image_processor ,__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' a = self.get_image_processor() a = self.get_feature_extractor() a = TvltProcessor(image_processor=__lowerCamelCase ,feature_extractor=__lowerCamelCase ) a = np.ones([1_20_00] ) a = feature_extractor(__lowerCamelCase ,return_tensors='''np''' ) a = processor(audio=__lowerCamelCase ,return_tensors='''np''' ) for key in audio_dict.keys(): self.assertAlmostEqual(audio_dict[key].sum() ,input_processor[key].sum() ,delta=1e-2 ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ): '''simple docstring''' a = self.get_image_processor() a = self.get_feature_extractor() a = TvltProcessor(image_processor=__lowerCamelCase ,feature_extractor=__lowerCamelCase ) a = np.ones([3, 2_24, 2_24] ) a = image_processor(__lowerCamelCase ,return_tensors='''np''' ) a = processor(images=__lowerCamelCase ,return_tensors='''np''' ) for key in image_dict.keys(): self.assertAlmostEqual(image_dict[key].sum() ,input_processor[key].sum() ,delta=1e-2 ) def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' a = self.get_image_processor() a = self.get_feature_extractor() a = TvltProcessor(image_processor=__lowerCamelCase ,feature_extractor=__lowerCamelCase ) a = np.ones([1_20_00] ) a = np.ones([3, 2_24, 2_24] ) a = processor(audio=__lowerCamelCase ,images=__lowerCamelCase ) self.assertListEqual(list(inputs.keys() ) ,['''audio_values''', '''audio_mask''', '''pixel_values''', '''pixel_mask'''] ) # test if it raises when no input is passed with pytest.raises(__lowerCamelCase ): processor() def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' a = self.get_image_processor() a = self.get_feature_extractor() a = TvltProcessor(image_processor=__lowerCamelCase ,feature_extractor=__lowerCamelCase ) self.assertListEqual( processor.model_input_names ,image_processor.model_input_names + feature_extractor.model_input_names ,msg='''`processor` and `image_processor`+`feature_extractor` model input names do not match''' ,)
356
import numpy as np import pandas as pd from sklearn.preprocessing import MinMaxScaler from tensorflow.keras.layers import LSTM, Dense from tensorflow.keras.models import Sequential if __name__ == "__main__": UpperCamelCase__ : Optional[int] = pd.read_csv("""sample_data.csv""", header=None) UpperCamelCase__ : Tuple = df.shape[:1][0] # If you're using some other dataset input the target column UpperCamelCase__ : List[Any] = df.iloc[:, 1:2] UpperCamelCase__ : Union[str, Any] = actual_data.values.reshape(len_data, 1) UpperCamelCase__ : List[Any] = MinMaxScaler().fit_transform(actual_data) UpperCamelCase__ : Optional[Any] = 10 UpperCamelCase__ : int = 5 UpperCamelCase__ : List[str] = 20 UpperCamelCase__ : Optional[int] = len_data - periods * look_back UpperCamelCase__ : Union[str, Any] = actual_data[:division] UpperCamelCase__ : str = actual_data[division - look_back :] UpperCamelCase__ , UpperCamelCase__ : Union[str, Any] = [], [] UpperCamelCase__ , UpperCamelCase__ : str = [], [] for i in range(0, len(train_data) - forward_days - look_back + 1): train_x.append(train_data[i : i + look_back]) train_y.append(train_data[i + look_back : i + look_back + forward_days]) for i in range(0, len(test_data) - forward_days - look_back + 1): test_x.append(test_data[i : i + look_back]) test_y.append(test_data[i + look_back : i + look_back + forward_days]) UpperCamelCase__ : List[str] = np.array(train_x) UpperCamelCase__ : Optional[Any] = np.array(test_x) UpperCamelCase__ : Tuple = np.array([list(i.ravel()) for i in train_y]) UpperCamelCase__ : Optional[Any] = np.array([list(i.ravel()) for i in test_y]) UpperCamelCase__ : Union[str, Any] = Sequential() model.add(LSTM(128, input_shape=(look_back, 1), return_sequences=True)) model.add(LSTM(64, input_shape=(128, 1))) model.add(Dense(forward_days)) model.compile(loss="""mean_squared_error""", optimizer="""adam""") UpperCamelCase__ : Tuple = model.fit( x_train, y_train, epochs=150, verbose=1, shuffle=True, batch_size=4 ) UpperCamelCase__ : Tuple = model.predict(x_test)
330
0
from typing import Dict from .base import GenericTensor, Pipeline class lowerCamelCase_ ( a_ ): def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : List[Any]=None ,__lowerCamelCase : Optional[int]=None ,__lowerCamelCase : Any=None ,**__lowerCamelCase : Dict ): '''simple docstring''' if tokenize_kwargs is None: a = {} if truncation is not None: if "truncation" in tokenize_kwargs: raise ValueError( '''truncation parameter defined twice (given as keyword argument as well as in tokenize_kwargs)''' ) a = truncation a = tokenize_kwargs a = {} if return_tensors is not None: a = return_tensors return preprocess_params, {}, postprocess_params def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : Tuple ,**__lowerCamelCase : Dict ): '''simple docstring''' a = self.framework a = self.tokenizer(_snake_case ,return_tensors=_snake_case ,**_snake_case ) return model_inputs def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : Optional[int] ): '''simple docstring''' a = self.model(**_snake_case ) return model_outputs def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : Any ,__lowerCamelCase : int=False ): '''simple docstring''' if return_tensors: return model_outputs[0] if self.framework == "pt": return model_outputs[0].tolist() elif self.framework == "tf": return model_outputs[0].numpy().tolist() def __call__( self : Any ,*__lowerCamelCase : int ,**__lowerCamelCase : List[Any] ): '''simple docstring''' return super().__call__(*_snake_case ,**_snake_case )
357
import os import time import pytest from datasets.utils.filelock import FileLock, Timeout def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Tuple: """simple docstring""" a = FileLock(str(tmpdir / '''foo.lock''' ) ) a = FileLock(str(tmpdir / '''foo.lock''' ) ) a = 0.01 with locka.acquire(): with pytest.raises(snake_case_ ): a = time.time() locka.acquire(snake_case_ ) assert time.time() - _start > timeout def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Optional[int]: """simple docstring""" a = '''a''' * 1_0_0_0 + '''.lock''' a = FileLock(str(tmpdir / filename ) ) assert locka._lock_file.endswith('''.lock''' ) assert not locka._lock_file.endswith(snake_case_ ) assert len(os.path.basename(locka._lock_file ) ) <= 2_5_5 a = FileLock(tmpdir / filename ) with locka.acquire(): with pytest.raises(snake_case_ ): locka.acquire(0 )
330
0
UpperCamelCase__ : int = 256 # Modulus to hash a string UpperCamelCase__ : Any = 1_000_003 def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> Any: """simple docstring""" a = len(lowerCamelCase_ ) a = len(lowerCamelCase_ ) if p_len > t_len: return False a = 0 a = 0 a = 1 # Calculating the hash of pattern and substring of text for i in range(lowerCamelCase_ ): a = (ord(pattern[i] ) + p_hash * alphabet_size) % modulus a = (ord(text[i] ) + text_hash * alphabet_size) % modulus if i == p_len - 1: continue a = (modulus_power * alphabet_size) % modulus for i in range(0, t_len - p_len + 1 ): if text_hash == p_hash and text[i : i + p_len] == pattern: return True if i == t_len - p_len: continue # Calculate the https://en.wikipedia.org/wiki/Rolling_hash a = ( (text_hash - ord(text[i] ) * modulus_power) * alphabet_size + ord(text[i + p_len] ) ) % modulus return False def SCREAMING_SNAKE_CASE__ ( ) -> Tuple: """simple docstring""" a = """abc1abc12""" a = """alskfjaldsabc1abc1abc12k23adsfabcabc""" a = """alskfjaldsk23adsfabcabc""" assert rabin_karp(lowerCamelCase_, lowerCamelCase_ ) and not rabin_karp(lowerCamelCase_, lowerCamelCase_ ) # Test 2) a = """ABABX""" a = """ABABZABABYABABX""" assert rabin_karp(lowerCamelCase_, lowerCamelCase_ ) # Test 3) a = """AAAB""" a = """ABAAAAAB""" assert rabin_karp(lowerCamelCase_, lowerCamelCase_ ) # Test 4) a = """abcdabcy""" a = """abcxabcdabxabcdabcdabcy""" assert rabin_karp(lowerCamelCase_, lowerCamelCase_ ) # Test 5) a = """Lü""" a = """Lüsai""" assert rabin_karp(lowerCamelCase_, lowerCamelCase_ ) a = """Lue""" assert not rabin_karp(lowerCamelCase_, lowerCamelCase_ ) print('''Success.''' ) if __name__ == "__main__": test_rabin_karp()
358
from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCamelCase__ : Optional[int] = logging.get_logger(__name__) UpperCamelCase__ : Dict = { """facebook/vit-mae-base""": """https://huggingface.co/facebook/vit-mae-base/resolve/main/config.json""", # See all ViT MAE models at https://huggingface.co/models?filter=vit-mae } class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = 'vit_mae' def __init__( self : Dict ,__lowerCamelCase : Any=7_68 ,__lowerCamelCase : Optional[Any]=12 ,__lowerCamelCase : List[str]=12 ,__lowerCamelCase : Optional[int]=30_72 ,__lowerCamelCase : int="gelu" ,__lowerCamelCase : Union[str, Any]=0.0 ,__lowerCamelCase : Optional[int]=0.0 ,__lowerCamelCase : Dict=0.02 ,__lowerCamelCase : List[Any]=1e-12 ,__lowerCamelCase : Dict=2_24 ,__lowerCamelCase : str=16 ,__lowerCamelCase : Union[str, Any]=3 ,__lowerCamelCase : Optional[Any]=True ,__lowerCamelCase : Dict=16 ,__lowerCamelCase : List[str]=5_12 ,__lowerCamelCase : int=8 ,__lowerCamelCase : int=20_48 ,__lowerCamelCase : Optional[Any]=0.75 ,__lowerCamelCase : int=False ,**__lowerCamelCase : Any ,): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = hidden_size a = num_hidden_layers a = num_attention_heads a = intermediate_size a = hidden_act a = hidden_dropout_prob a = attention_probs_dropout_prob a = initializer_range a = layer_norm_eps a = image_size a = patch_size a = num_channels a = qkv_bias a = decoder_num_attention_heads a = decoder_hidden_size a = decoder_num_hidden_layers a = decoder_intermediate_size a = mask_ratio a = norm_pix_loss
330
0
from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCamelCase__ : Any = logging.get_logger(__name__) UpperCamelCase__ : Optional[int] = { """microsoft/markuplm-base""": """https://huggingface.co/microsoft/markuplm-base/resolve/main/config.json""", """microsoft/markuplm-large""": """https://huggingface.co/microsoft/markuplm-large/resolve/main/config.json""", } class lowerCamelCase_ ( __A ): SCREAMING_SNAKE_CASE_ = 'markuplm' def __init__( self : Optional[int] ,__lowerCamelCase : Tuple=3_05_22 ,__lowerCamelCase : Optional[int]=7_68 ,__lowerCamelCase : Tuple=12 ,__lowerCamelCase : int=12 ,__lowerCamelCase : List[str]=30_72 ,__lowerCamelCase : List[Any]="gelu" ,__lowerCamelCase : str=0.1 ,__lowerCamelCase : Optional[int]=0.1 ,__lowerCamelCase : int=5_12 ,__lowerCamelCase : Optional[Any]=2 ,__lowerCamelCase : Optional[int]=0.02 ,__lowerCamelCase : Any=1e-12 ,__lowerCamelCase : Dict=0 ,__lowerCamelCase : List[Any]=0 ,__lowerCamelCase : Dict=2 ,__lowerCamelCase : List[Any]=2_56 ,__lowerCamelCase : List[str]=10_24 ,__lowerCamelCase : str=2_16 ,__lowerCamelCase : Union[str, Any]=10_01 ,__lowerCamelCase : Union[str, Any]=32 ,__lowerCamelCase : Union[str, Any]=50 ,__lowerCamelCase : Union[str, Any]="absolute" ,__lowerCamelCase : Union[str, Any]=True ,__lowerCamelCase : List[Any]=None ,**__lowerCamelCase : Dict ,): '''simple docstring''' super().__init__( pad_token_id=__lowercase ,bos_token_id=__lowercase ,eos_token_id=__lowercase ,**__lowercase ,) a = vocab_size a = hidden_size a = num_hidden_layers a = num_attention_heads a = hidden_act a = intermediate_size a = hidden_dropout_prob a = attention_probs_dropout_prob a = max_position_embeddings a = type_vocab_size a = initializer_range a = layer_norm_eps a = position_embedding_type a = use_cache a = classifier_dropout # additional properties a = max_depth a = max_xpath_tag_unit_embeddings a = max_xpath_subs_unit_embeddings a = tag_pad_id a = subs_pad_id a = xpath_unit_hidden_size
359
def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Union[str, Any]: """simple docstring""" stooge(snake_case_, 0, len(snake_case_ ) - 1 ) return arr def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> Optional[Any]: """simple docstring""" if i >= h: return # If first element is smaller than the last then swap them if arr[i] > arr[h]: a , a = arr[h], arr[i] # If there are more than 2 elements in the array if h - i + 1 > 2: a = (int)((h - i + 1) / 3 ) # Recursively sort first 2/3 elements stooge(snake_case_, snake_case_, (h - t) ) # Recursively sort last 2/3 elements stooge(snake_case_, i + t, (snake_case_) ) # Recursively sort first 2/3 elements stooge(snake_case_, snake_case_, (h - t) ) if __name__ == "__main__": UpperCamelCase__ : Dict = input("""Enter numbers separated by a comma:\n""").strip() UpperCamelCase__ : Optional[int] = [int(item) for item in user_input.split(""",""")] print(stooge_sort(unsorted))
330
0
def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_ ) -> Optional[Any]: """simple docstring""" a = len(__lowerCamelCase ), len(grid[0] ) if ( min(__lowerCamelCase, __lowerCamelCase ) < 0 or row == row_length or col == col_length or (row, col) in visit or grid[row][col] == 1 ): return 0 if row == row_length - 1 and col == col_length - 1: return 1 visit.add((row, col) ) a = 0 count += depth_first_search(__lowerCamelCase, row + 1, __lowerCamelCase, __lowerCamelCase ) count += depth_first_search(__lowerCamelCase, row - 1, __lowerCamelCase, __lowerCamelCase ) count += depth_first_search(__lowerCamelCase, __lowerCamelCase, col + 1, __lowerCamelCase ) count += depth_first_search(__lowerCamelCase, __lowerCamelCase, col - 1, __lowerCamelCase ) visit.remove((row, col) ) return count if __name__ == "__main__": import doctest doctest.testmod()
360
import json import os import re import unicodedata from json.encoder import INFINITY from typing import Any, Dict, List, Optional, Tuple, Union import numpy as np import regex from ...tokenization_utils import AddedToken, PreTrainedTokenizer from ...tokenization_utils_base import BatchEncoding from ...utils import TensorType, is_flax_available, is_tf_available, is_torch_available, logging from ...utils.generic import _is_jax, _is_numpy UpperCamelCase__ : Any = logging.get_logger(__name__) UpperCamelCase__ : Optional[Any] = { """artists_file""": """artists.json""", """lyrics_file""": """lyrics.json""", """genres_file""": """genres.json""", } UpperCamelCase__ : Union[str, Any] = { """artists_file""": { """jukebox""": """https://huggingface.co/ArthurZ/jukebox/blob/main/artists.json""", }, """genres_file""": { """jukebox""": """https://huggingface.co/ArthurZ/jukebox/blob/main/genres.json""", }, """lyrics_file""": { """jukebox""": """https://huggingface.co/ArthurZ/jukebox/blob/main/lyrics.json""", }, } UpperCamelCase__ : str = { """jukebox""": 512, } class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = VOCAB_FILES_NAMES SCREAMING_SNAKE_CASE_ = PRETRAINED_VOCAB_FILES_MAP SCREAMING_SNAKE_CASE_ = PRETRAINED_LYRIC_TOKENS_SIZES SCREAMING_SNAKE_CASE_ = ['input_ids', 'attention_mask'] def __init__( self : Optional[Any] ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : List[Any] ,__lowerCamelCase : Tuple ,__lowerCamelCase : Union[str, Any]=["v3", "v2", "v2"] ,__lowerCamelCase : List[Any]=5_12 ,__lowerCamelCase : Tuple=5 ,__lowerCamelCase : List[Any]="<|endoftext|>" ,**__lowerCamelCase : List[str] ,): '''simple docstring''' a = AddedToken(__lowerCamelCase ,lstrip=__lowerCamelCase ,rstrip=__lowerCamelCase ) if isinstance(__lowerCamelCase ,__lowerCamelCase ) else unk_token super().__init__( unk_token=__lowerCamelCase ,n_genres=__lowerCamelCase ,version=__lowerCamelCase ,max_n_lyric_tokens=__lowerCamelCase ,**__lowerCamelCase ,) a = version a = max_n_lyric_tokens a = n_genres with open(__lowerCamelCase ,encoding='''utf-8''' ) as vocab_handle: a = json.load(__lowerCamelCase ) with open(__lowerCamelCase ,encoding='''utf-8''' ) as vocab_handle: a = json.load(__lowerCamelCase ) with open(__lowerCamelCase ,encoding='''utf-8''' ) as vocab_handle: a = json.load(__lowerCamelCase ) a = r'''[^A-Za-z0-9.,:;!?\-\'\"()\[\] \t\n]+''' # In v2, we had a n_vocab=80 and in v3 we missed + and so n_vocab=79 of characters. if len(self.lyrics_encoder ) == 79: a = oov.replace(r'''\-\'''' ,r'''\-+\'''' ) a = regex.compile(__lowerCamelCase ) a = {v: k for k, v in self.artists_encoder.items()} a = {v: k for k, v in self.genres_encoder.items()} a = {v: k for k, v in self.lyrics_encoder.items()} @property def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' return len(self.artists_encoder ) + len(self.genres_encoder ) + len(self.lyrics_encoder ) def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ): '''simple docstring''' return dict(self.artists_encoder ,self.genres_encoder ,self.lyrics_encoder ) def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : Optional[int] ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : List[Any] ): '''simple docstring''' a = [self.artists_encoder.get(__lowerCamelCase ,0 ) for artist in list_artists] for genres in range(len(__lowerCamelCase ) ): a = [self.genres_encoder.get(__lowerCamelCase ,0 ) for genre in list_genres[genres]] a = list_genres[genres] + [-1] * (self.n_genres - len(list_genres[genres] )) a = [[self.lyrics_encoder.get(__lowerCamelCase ,0 ) for character in list_lyrics[0]], [], []] return artists_id, list_genres, lyric_ids def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : List[str] ): '''simple docstring''' return list(__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : List[Any] ,__lowerCamelCase : Any ,__lowerCamelCase : Optional[int] ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' a , a , a = self.prepare_for_tokenization(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ) a = self._tokenize(__lowerCamelCase ) return artist, genre, lyrics def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : str ,__lowerCamelCase : str ,__lowerCamelCase : str ,__lowerCamelCase : bool = False ): '''simple docstring''' for idx in range(len(self.version ) ): if self.version[idx] == "v3": a = artists[idx].lower() a = [genres[idx].lower()] else: a = self._normalize(artists[idx] ) + '''.v2''' a = [ self._normalize(__lowerCamelCase ) + '''.v2''' for genre in genres[idx].split('''_''' ) ] # split is for the full dictionary with combined genres if self.version[0] == "v2": a = regex.compile(r'''[^A-Za-z0-9.,:;!?\-\'\"()\[\] \t\n]+''' ) a = '''ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.,:;!?-+\'\"()[] \t\n''' a = {vocab[index]: index + 1 for index in range(len(__lowerCamelCase ) )} a = 0 a = len(__lowerCamelCase ) + 1 a = self.vocab a = {v: k for k, v in self.vocab.items()} a = '''''' else: a = regex.compile(r'''[^A-Za-z0-9.,:;!?\-+\'\"()\[\] \t\n]+''' ) a = self._run_strip_accents(__lowerCamelCase ) a = lyrics.replace('''\\''' ,'''\n''' ) a = self.out_of_vocab.sub('''''' ,__lowerCamelCase ), [], [] return artists, genres, lyrics def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : int ): '''simple docstring''' a = unicodedata.normalize('''NFD''' ,__lowerCamelCase ) a = [] for char in text: a = unicodedata.category(__lowerCamelCase ) if cat == "Mn": continue output.append(__lowerCamelCase ) return "".join(__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : str ): '''simple docstring''' a = ( [chr(__lowerCamelCase ) for i in range(ord('''a''' ) ,ord('''z''' ) + 1 )] + [chr(__lowerCamelCase ) for i in range(ord('''A''' ) ,ord('''Z''' ) + 1 )] + [chr(__lowerCamelCase ) for i in range(ord('''0''' ) ,ord('''9''' ) + 1 )] + ['''.'''] ) a = frozenset(__lowerCamelCase ) a = re.compile(r'''_+''' ) a = ''''''.join([c if c in accepted else '''_''' for c in text.lower()] ) a = pattern.sub('''_''' ,__lowerCamelCase ).strip('''_''' ) return text def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : List[str] ): '''simple docstring''' return " ".join(__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : str ,__lowerCamelCase : Optional[Union[str, TensorType]] = None ,__lowerCamelCase : bool = False ): '''simple docstring''' if not isinstance(__lowerCamelCase ,__lowerCamelCase ): a = TensorType(__lowerCamelCase ) # Get a function reference for the correct framework if tensor_type == TensorType.TENSORFLOW: if not is_tf_available(): raise ImportError( '''Unable to convert output to TensorFlow tensors format, TensorFlow is not installed.''' ) import tensorflow as tf a = tf.constant a = tf.is_tensor elif tensor_type == TensorType.PYTORCH: if not is_torch_available(): raise ImportError('''Unable to convert output to PyTorch tensors format, PyTorch is not installed.''' ) import torch a = torch.tensor a = torch.is_tensor elif tensor_type == TensorType.JAX: if not is_flax_available(): raise ImportError('''Unable to convert output to JAX tensors format, JAX is not installed.''' ) import jax.numpy as jnp # noqa: F811 a = jnp.array a = _is_jax else: a = np.asarray a = _is_numpy # Do the tensor conversion in batch try: if prepend_batch_axis: a = [inputs] if not is_tensor(__lowerCamelCase ): a = as_tensor(__lowerCamelCase ) except: # noqa E722 raise ValueError( '''Unable to create tensor, you should probably activate truncation and/or padding ''' '''with \'padding=True\' \'truncation=True\' to have batched tensors with the same length.''' ) return inputs def __call__( self : Tuple ,__lowerCamelCase : Tuple ,__lowerCamelCase : Optional[int] ,__lowerCamelCase : List[str]="" ,__lowerCamelCase : List[Any]="pt" ): '''simple docstring''' a = [0, 0, 0] a = [artist] * len(self.version ) a = [genres] * len(self.version ) a , a , a = self.tokenize(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ) a , a , a = self._convert_token_to_id(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ) a = [-INFINITY] * len(full_tokens[-1] ) a = [ self.convert_to_tensors( [input_ids + [artists_id[i]] + genres_ids[i] + full_tokens[i]] ,tensor_type=__lowerCamelCase ) for i in range(len(self.version ) ) ] return BatchEncoding({'''input_ids''': input_ids, '''attention_masks''': attention_masks} ) def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : str ,__lowerCamelCase : Optional[str] = None ): '''simple docstring''' if not os.path.isdir(__lowerCamelCase ): logger.error(F"""Vocabulary path ({save_directory}) should be a directory""" ) return a = os.path.join( __lowerCamelCase ,(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''artists_file'''] ) with open(__lowerCamelCase ,'''w''' ,encoding='''utf-8''' ) as f: f.write(json.dumps(self.artists_encoder ,ensure_ascii=__lowerCamelCase ) ) a = os.path.join( __lowerCamelCase ,(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''genres_file'''] ) with open(__lowerCamelCase ,'''w''' ,encoding='''utf-8''' ) as f: f.write(json.dumps(self.genres_encoder ,ensure_ascii=__lowerCamelCase ) ) a = os.path.join( __lowerCamelCase ,(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''lyrics_file'''] ) with open(__lowerCamelCase ,'''w''' ,encoding='''utf-8''' ) as f: f.write(json.dumps(self.lyrics_encoder ,ensure_ascii=__lowerCamelCase ) ) return (artists_file, genres_file, lyrics_file) def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : Any ,__lowerCamelCase : Any ,__lowerCamelCase : str ): '''simple docstring''' a = self.artists_decoder.get(__lowerCamelCase ) a = [self.genres_decoder.get(__lowerCamelCase ) for genre in genres_index] a = [self.lyrics_decoder.get(__lowerCamelCase ) for character in lyric_index] return artist, genres, lyrics
330
0
from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging UpperCamelCase__ : List[Any] = logging.get_logger(__name__) UpperCamelCase__ : Optional[Any] = { """facebook/data2vec-text-base""": """https://huggingface.co/data2vec/resolve/main/config.json""", } class lowerCamelCase_ ( __SCREAMING_SNAKE_CASE ): SCREAMING_SNAKE_CASE_ = 'data2vec-text' def __init__( self : List[str] ,__lowerCamelCase : str=3_05_22 ,__lowerCamelCase : Any=7_68 ,__lowerCamelCase : str=12 ,__lowerCamelCase : str=12 ,__lowerCamelCase : Optional[int]=30_72 ,__lowerCamelCase : List[str]="gelu" ,__lowerCamelCase : List[Any]=0.1 ,__lowerCamelCase : str=0.1 ,__lowerCamelCase : List[str]=5_12 ,__lowerCamelCase : Union[str, Any]=2 ,__lowerCamelCase : List[str]=0.02 ,__lowerCamelCase : Optional[int]=1e-12 ,__lowerCamelCase : Union[str, Any]=1 ,__lowerCamelCase : Optional[int]=0 ,__lowerCamelCase : Optional[Any]=2 ,__lowerCamelCase : Any="absolute" ,__lowerCamelCase : List[Any]=True ,__lowerCamelCase : Union[str, Any]=None ,**__lowerCamelCase : List[Any] ,): '''simple docstring''' super().__init__(pad_token_id=_a ,bos_token_id=_a ,eos_token_id=_a ,**_a ) a = vocab_size a = hidden_size a = num_hidden_layers a = num_attention_heads a = hidden_act a = intermediate_size a = hidden_dropout_prob a = attention_probs_dropout_prob a = max_position_embeddings a = type_vocab_size a = initializer_range a = layer_norm_eps a = position_embedding_type a = use_cache a = classifier_dropout class lowerCamelCase_ ( __SCREAMING_SNAKE_CASE ): @property def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ): '''simple docstring''' if self.task == "multiple-choice": a = {0: '''batch''', 1: '''choice''', 2: '''sequence'''} else: a = {0: '''batch''', 1: '''sequence'''} return OrderedDict( [ ('''input_ids''', dynamic_axis), ('''attention_mask''', dynamic_axis), ] )
361
# This script creates a super tiny model that is useful inside tests, when we just want to test that # the machinery works, without needing to the check the quality of the outcomes. # # This version creates a tiny vocab first, and then a tiny model - so the outcome is truly tiny - # all files ~60KB. As compared to taking a full-size model, reducing to the minimum its layers and # emb dimensions, but keeping the full vocab + merges files, leading to ~3MB in total for all files. # The latter is done by `fsmt-make-super-tiny-model.py`. # # It will be used then as "stas/tiny-wmt19-en-ru" from pathlib import Path import json import tempfile from transformers import FSMTTokenizer, FSMTConfig, FSMTForConditionalGeneration from transformers.models.fsmt.tokenization_fsmt import VOCAB_FILES_NAMES UpperCamelCase__ : Optional[Any] = """tiny-wmt19-en-ru""" # Build # borrowed from a test UpperCamelCase__ : Any = [ """l""", """o""", """w""", """e""", """r""", """s""", """t""", """i""", """d""", """n""", """w</w>""", """r</w>""", """t</w>""", """lo""", """low""", """er</w>""", """low</w>""", """lowest</w>""", """newer</w>""", """wider</w>""", """<unk>""", ] UpperCamelCase__ : List[Any] = dict(zip(vocab, range(len(vocab)))) UpperCamelCase__ : Any = ["""l o 123""", """lo w 1456""", """e r</w> 1789""", """"""] with tempfile.TemporaryDirectory() as tmpdirname: UpperCamelCase__ : Optional[Any] = Path(tmpdirname) UpperCamelCase__ : Tuple = build_dir / VOCAB_FILES_NAMES["""src_vocab_file"""] UpperCamelCase__ : int = build_dir / VOCAB_FILES_NAMES["""tgt_vocab_file"""] UpperCamelCase__ : Union[str, Any] = build_dir / VOCAB_FILES_NAMES["""merges_file"""] with open(src_vocab_file, """w""") as fp: fp.write(json.dumps(vocab_tokens)) with open(tgt_vocab_file, """w""") as fp: fp.write(json.dumps(vocab_tokens)) with open(merges_file, """w""") as fp: fp.write("""\n""".join(merges)) UpperCamelCase__ : Dict = FSMTTokenizer( langs=["""en""", """ru"""], src_vocab_size=len(vocab), tgt_vocab_size=len(vocab), src_vocab_file=src_vocab_file, tgt_vocab_file=tgt_vocab_file, merges_file=merges_file, ) UpperCamelCase__ : Union[str, Any] = FSMTConfig( langs=["""ru""", """en"""], src_vocab_size=1_000, tgt_vocab_size=1_000, d_model=4, encoder_layers=1, decoder_layers=1, encoder_ffn_dim=4, decoder_ffn_dim=4, encoder_attention_heads=1, decoder_attention_heads=1, ) UpperCamelCase__ : Union[str, Any] = FSMTForConditionalGeneration(config) print(F"num of params {tiny_model.num_parameters()}") # Test UpperCamelCase__ : List[str] = tokenizer(["""Making tiny model"""], return_tensors="""pt""") UpperCamelCase__ : Tuple = tiny_model(**batch) print("""test output:""", len(outputs.logits[0])) # Save tiny_model.half() # makes it smaller tiny_model.save_pretrained(mname_tiny) tokenizer.save_pretrained(mname_tiny) print(F"Generated {mname_tiny}") # Upload # transformers-cli upload tiny-wmt19-en-ru
330
0
import os import unicodedata from shutil import copyfile from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import AddedToken, PreTrainedTokenizer from ...utils import SPIECE_UNDERLINE, logging UpperCamelCase__ : Any = logging.get_logger(__name__) UpperCamelCase__ : int = {"""vocab_file""": """spiece.model"""} UpperCamelCase__ : Tuple = { """vocab_file""": { """xlnet-base-cased""": """https://huggingface.co/xlnet-base-cased/resolve/main/spiece.model""", """xlnet-large-cased""": """https://huggingface.co/xlnet-large-cased/resolve/main/spiece.model""", } } UpperCamelCase__ : Tuple = { """xlnet-base-cased""": None, """xlnet-large-cased""": None, } # Segments (not really needed) UpperCamelCase__ : Any = 0 UpperCamelCase__ : Optional[int] = 1 UpperCamelCase__ : Optional[Any] = 2 UpperCamelCase__ : Optional[Any] = 3 UpperCamelCase__ : List[Any] = 4 class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = VOCAB_FILES_NAMES SCREAMING_SNAKE_CASE_ = PRETRAINED_VOCAB_FILES_MAP SCREAMING_SNAKE_CASE_ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES SCREAMING_SNAKE_CASE_ = 'left' def __init__( self : Tuple ,__lowerCamelCase : Tuple ,__lowerCamelCase : List[str]=False ,__lowerCamelCase : Optional[Any]=True ,__lowerCamelCase : Any=False ,__lowerCamelCase : int="<s>" ,__lowerCamelCase : Union[str, Any]="</s>" ,__lowerCamelCase : List[Any]="<unk>" ,__lowerCamelCase : Any="<sep>" ,__lowerCamelCase : int="<pad>" ,__lowerCamelCase : Any="<cls>" ,__lowerCamelCase : Optional[int]="<mask>" ,__lowerCamelCase : List[str]=["<eop>", "<eod>"] ,__lowerCamelCase : str = None ,**__lowerCamelCase : Optional[int] ,): '''simple docstring''' a = AddedToken(__lowerCamelCase ,lstrip=__lowerCamelCase ,rstrip=__lowerCamelCase ) if isinstance(__lowerCamelCase ,__lowerCamelCase ) else mask_token a = {} 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 ,additional_special_tokens=__lowerCamelCase ,sp_model_kwargs=self.sp_model_kwargs ,**__lowerCamelCase ,) a = 3 a = do_lower_case a = remove_space a = keep_accents a = vocab_file a = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(__lowerCamelCase ) @property def SCREAMING_SNAKE_CASE_ ( self : List[str] ): '''simple docstring''' return len(self.sp_model ) def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' a = {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 : Tuple ): '''simple docstring''' a = self.__dict__.copy() a = None return state def __setstate__( self : Optional[int] ,__lowerCamelCase : List[str] ): '''simple docstring''' a = d # for backward compatibility if not hasattr(self ,'''sp_model_kwargs''' ): a = {} a = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(self.vocab_file ) def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : List[str] ): '''simple docstring''' if self.remove_space: a = ' '.join(inputs.strip().split() ) else: a = inputs a = outputs.replace('''``''' ,'''"''' ).replace('''\'\'''' ,'''"''' ) if not self.keep_accents: a = unicodedata.normalize('''NFKD''' ,__lowerCamelCase ) a = ''.join([c for c in outputs if not unicodedata.combining(__lowerCamelCase )] ) if self.do_lower_case: a = outputs.lower() return outputs def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = self.preprocess_text(__lowerCamelCase ) a = self.sp_model.encode(__lowerCamelCase ,out_type=__lowerCamelCase ) a = [] for piece in pieces: if len(__lowerCamelCase ) > 1 and piece[-1] == str(''',''' ) and piece[-2].isdigit(): a = 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 = cur_pieces[1:] else: a = 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 : str ,__lowerCamelCase : Any ): '''simple docstring''' return self.sp_model.PieceToId(__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ,__lowerCamelCase : Optional[int] ): '''simple docstring''' return self.sp_model.IdToPiece(__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = ''.join(__lowerCamelCase ).replace(__lowerCamelCase ,''' ''' ).strip() return out_string def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : List[Any] ,__lowerCamelCase : Any = False ,__lowerCamelCase : Dict = None ,__lowerCamelCase : Dict = True ,**__lowerCamelCase : Union[str, Any] ,): '''simple docstring''' a = kwargs.pop('''use_source_tokenizer''' ,__lowerCamelCase ) a = self.convert_ids_to_tokens(__lowerCamelCase ,skip_special_tokens=__lowerCamelCase ) # 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 a = [] a = [] 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(__lowerCamelCase ) ) a = [] sub_texts.append(__lowerCamelCase ) else: current_sub_text.append(__lowerCamelCase ) if current_sub_text: sub_texts.append(self.convert_tokens_to_string(__lowerCamelCase ) ) # Mimic the behavior of the Rust tokenizer: # By default, there are no spaces between special tokens a = ''.join(__lowerCamelCase ) a = ( clean_up_tokenization_spaces if clean_up_tokenization_spaces is not None else self.clean_up_tokenization_spaces ) if clean_up_tokenization_spaces: a = self.clean_up_tokenization(__lowerCamelCase ) return clean_text else: return text def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : str ,__lowerCamelCase : Optional[Any] = None ): '''simple docstring''' a = [self.sep_token_id] a = [self.cls_token_id] if token_ids_a is None: return token_ids_a + sep + cls return token_ids_a + sep + token_ids_a + sep + cls def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : Union[str, Any] ,__lowerCamelCase : List[str] = None ,__lowerCamelCase : Union[str, Any] = False ): '''simple docstring''' if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=__lowerCamelCase ,token_ids_a=__lowerCamelCase ,already_has_special_tokens=__lowerCamelCase ) if token_ids_a is not None: return ([0] * len(__lowerCamelCase )) + [1] + ([0] * len(__lowerCamelCase )) + [1, 1] return ([0] * len(__lowerCamelCase )) + [1, 1] def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : Optional[int] ,__lowerCamelCase : Any = None ): '''simple docstring''' a = [self.sep_token_id] a = [2] if token_ids_a is None: return len(token_ids_a + sep ) * [0] + cls_segment_id return len(token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] + cls_segment_id def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ,__lowerCamelCase : List[Any] ,__lowerCamelCase : Tuple = None ): '''simple docstring''' if not os.path.isdir(__lowerCamelCase ): logger.error(F"""Vocabulary path ({save_directory}) should be a directory""" ) return a = 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 = self.sp_model.serialized_model_proto() fi.write(__lowerCamelCase ) return (out_vocab_file,)
362
import inspect import os import torch from transformers import AutoModel from transformers.testing_utils import mockenv_context from transformers.trainer_utils import set_seed import accelerate from accelerate.accelerator import Accelerator from accelerate.state import AcceleratorState from accelerate.test_utils.testing import ( AccelerateTestCase, TempDirTestCase, execute_subprocess_async, require_cuda, require_fsdp, require_multi_gpu, slow, ) from accelerate.utils.constants import ( FSDP_AUTO_WRAP_POLICY, FSDP_BACKWARD_PREFETCH, FSDP_SHARDING_STRATEGY, FSDP_STATE_DICT_TYPE, ) from accelerate.utils.dataclasses import FullyShardedDataParallelPlugin from accelerate.utils.other import patch_environment set_seed(42) UpperCamelCase__ : Optional[Any] = """bert-base-cased""" UpperCamelCase__ : int = """fp16""" UpperCamelCase__ : str = """bf16""" UpperCamelCase__ : List[Any] = [FPaa, BFaa] @require_fsdp @require_cuda class lowerCamelCase_ ( a_ ): def SCREAMING_SNAKE_CASE_ ( self : int ): '''simple docstring''' super().setUp() a = dict( ACCELERATE_USE_FSDP='''true''' ,MASTER_ADDR='''localhost''' ,MASTER_PORT='''10999''' ,RANK='''0''' ,LOCAL_RANK='''0''' ,WORLD_SIZE='''1''' ,) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import ShardingStrategy for i, strategy in enumerate(__lowerCamelCase ): a = self.dist_env.copy() a = F"""{i + 1}""" a = strategy with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() self.assertEqual(fsdp_plugin.sharding_strategy ,ShardingStrategy(i + 1 ) ) def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import BackwardPrefetch for i, prefetch_policy in enumerate(__lowerCamelCase ): a = self.dist_env.copy() a = prefetch_policy with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() if prefetch_policy == "NO_PREFETCH": self.assertIsNone(fsdp_plugin.backward_prefetch ) else: self.assertEqual(fsdp_plugin.backward_prefetch ,BackwardPrefetch(i + 1 ) ) def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType for i, state_dict_type in enumerate(__lowerCamelCase ): a = self.dist_env.copy() a = state_dict_type with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() self.assertEqual(fsdp_plugin.state_dict_type ,StateDictType(i + 1 ) ) if state_dict_type == "FULL_STATE_DICT": self.assertTrue(fsdp_plugin.state_dict_config.offload_to_cpu ) self.assertTrue(fsdp_plugin.state_dict_config.ranka_only ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ): '''simple docstring''' a = AutoModel.from_pretrained(__lowerCamelCase ) for policy in FSDP_AUTO_WRAP_POLICY: a = self.dist_env.copy() a = policy if policy == "TRANSFORMER_BASED_WRAP": a = '''BertLayer''' elif policy == "SIZE_BASED_WRAP": a = '''2000''' with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() fsdp_plugin.set_auto_wrap_policy(__lowerCamelCase ) if policy == "NO_WRAP": self.assertIsNone(fsdp_plugin.auto_wrap_policy ) else: self.assertIsNotNone(fsdp_plugin.auto_wrap_policy ) a = self.dist_env.copy() a = '''TRANSFORMER_BASED_WRAP''' a = '''T5Layer''' with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() with self.assertRaises(__lowerCamelCase ) as cm: fsdp_plugin.set_auto_wrap_policy(__lowerCamelCase ) self.assertTrue('''Could not find the transformer layer class to wrap in the model.''' in str(cm.exception ) ) a = self.dist_env.copy() a = '''SIZE_BASED_WRAP''' a = '''0''' with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() fsdp_plugin.set_auto_wrap_policy(__lowerCamelCase ) self.assertIsNone(fsdp_plugin.auto_wrap_policy ) def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import MixedPrecision from torch.distributed.fsdp.sharded_grad_scaler import ShardedGradScaler for mp_dtype in dtypes: a = self.dist_env.copy() a = mp_dtype with mockenv_context(**__lowerCamelCase ): a = Accelerator() if mp_dtype == "fp16": a = torch.floataa elif mp_dtype == "bf16": a = torch.bfloataa a = MixedPrecision(param_dtype=__lowerCamelCase ,reduce_dtype=__lowerCamelCase ,buffer_dtype=__lowerCamelCase ) self.assertEqual(accelerator.state.fsdp_plugin.mixed_precision_policy ,__lowerCamelCase ) if mp_dtype == FPaa: self.assertTrue(isinstance(accelerator.scaler ,__lowerCamelCase ) ) elif mp_dtype == BFaa: self.assertIsNone(accelerator.scaler ) AcceleratorState._reset_state(__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import CPUOffload for flag in [True, False]: a = self.dist_env.copy() a = str(__lowerCamelCase ).lower() with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() self.assertEqual(fsdp_plugin.cpu_offload ,CPUOffload(offload_params=__lowerCamelCase ) ) @require_fsdp @require_multi_gpu @slow class lowerCamelCase_ ( a_ ): def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' super().setUp() a = 0.82 a = [ '''fsdp_shard_grad_op_transformer_based_wrap''', '''fsdp_full_shard_transformer_based_wrap''', ] a = { '''multi_gpu_fp16''': 32_00, '''fsdp_shard_grad_op_transformer_based_wrap_fp16''': 20_00, '''fsdp_full_shard_transformer_based_wrap_fp16''': 19_00, # Disabling below test as it overwhelms the RAM memory usage # on CI self-hosted runner leading to tests getting killed. # "fsdp_full_shard_cpu_offload_transformer_based_wrap_fp32": 1500, # fp16 was leading to indefinite hang } a = 1_60 a = 1_60 a = inspect.getfile(accelerate.test_utils ) a = os.path.sep.join(mod_file.split(os.path.sep )[:-1] + ['''scripts''', '''external_deps'''] ) def SCREAMING_SNAKE_CASE_ ( self : List[str] ): '''simple docstring''' a = os.path.join(self.test_scripts_folder ,'''test_performance.py''' ) a = ['''accelerate''', '''launch''', '''--num_processes=2''', '''--num_machines=1''', '''--machine_rank=0''', '''--use_fsdp'''] for config in self.performance_configs: a = cmd.copy() for i, strategy in enumerate(__lowerCamelCase ): if strategy.lower() in config: cmd_config.append(F"""--fsdp_sharding_strategy={i+1}""" ) break if "fp32" in config: cmd_config.append('''--mixed_precision=no''' ) else: cmd_config.append('''--mixed_precision=fp16''' ) if "cpu_offload" in config: cmd_config.append('''--fsdp_offload_params=True''' ) for policy in FSDP_AUTO_WRAP_POLICY: if policy.lower() in config: cmd_config.append(F"""--fsdp_auto_wrap_policy={policy}""" ) break if policy == "TRANSFORMER_BASED_WRAP": cmd_config.append('''--fsdp_transformer_layer_cls_to_wrap=BertLayer''' ) elif policy == "SIZE_BASED_WRAP": cmd_config.append('''--fsdp_min_num_params=2000''' ) cmd_config.extend( [ self.test_file_path, F"""--output_dir={self.tmpdir}""", F"""--performance_lower_bound={self.performance_lower_bound}""", ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(__lowerCamelCase ,env=os.environ.copy() ) def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' a = os.path.join(self.test_scripts_folder ,'''test_checkpointing.py''' ) a = [ '''accelerate''', '''launch''', '''--num_processes=2''', '''--num_machines=1''', '''--machine_rank=0''', '''--use_fsdp''', '''--mixed_precision=fp16''', '''--fsdp_transformer_layer_cls_to_wrap=BertLayer''', ] for i, strategy in enumerate(__lowerCamelCase ): a = cmd.copy() cmd_config.append(F"""--fsdp_sharding_strategy={i+1}""" ) if strategy != "FULL_SHARD": continue a = len(__lowerCamelCase ) for state_dict_type in FSDP_STATE_DICT_TYPE: a = cmd_config[:state_dict_config_index] cmd_config.append(F"""--fsdp_state_dict_type={state_dict_type}""" ) cmd_config.extend( [ self.test_file_path, F"""--output_dir={self.tmpdir}""", '''--partial_train_epoch=1''', ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(__lowerCamelCase ,env=os.environ.copy() ) a = cmd_config[:-1] a = os.path.join(self.tmpdir ,'''epoch_0''' ) cmd_config.extend( [ F"""--resume_from_checkpoint={resume_from_checkpoint}""", ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(__lowerCamelCase ,env=os.environ.copy() ) def SCREAMING_SNAKE_CASE_ ( self : int ): '''simple docstring''' a = os.path.join(self.test_scripts_folder ,'''test_peak_memory_usage.py''' ) a = [ '''accelerate''', '''launch''', '''--num_processes=2''', '''--num_machines=1''', '''--machine_rank=0''', ] for spec, peak_mem_upper_bound in self.peak_memory_usage_upper_bound.items(): a = cmd.copy() if "fp16" in spec: cmd_config.extend(['''--mixed_precision=fp16'''] ) else: cmd_config.extend(['''--mixed_precision=no'''] ) if "multi_gpu" in spec: continue else: cmd_config.extend(['''--use_fsdp'''] ) for i, strategy in enumerate(__lowerCamelCase ): if strategy.lower() in spec: cmd_config.append(F"""--fsdp_sharding_strategy={i+1}""" ) break if "cpu_offload" in spec: cmd_config.append('''--fsdp_offload_params=True''' ) for policy in FSDP_AUTO_WRAP_POLICY: if policy.lower() in spec: cmd_config.append(F"""--fsdp_auto_wrap_policy={policy}""" ) break if policy == "TRANSFORMER_BASED_WRAP": cmd_config.append('''--fsdp_transformer_layer_cls_to_wrap=BertLayer''' ) elif policy == "SIZE_BASED_WRAP": cmd_config.append('''--fsdp_min_num_params=2000''' ) cmd_config.extend( [ self.test_file_path, F"""--output_dir={self.tmpdir}""", F"""--peak_memory_upper_bound={peak_mem_upper_bound}""", F"""--n_train={self.n_train}""", F"""--n_val={self.n_val}""", ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(__lowerCamelCase ,env=os.environ.copy() )
330
0
"""simple docstring""" from __future__ import annotations import collections import pprint from pathlib import Path def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> str: """simple docstring""" return "".join(sorted(_lowerCamelCase ) ) def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> list[str]: """simple docstring""" return word_by_signature[signature(_lowerCamelCase )] UpperCamelCase__ : Optional[Any] = Path(__file__).parent.joinpath("""words.txt""").read_text(encoding="""utf-8""") UpperCamelCase__ : List[Any] = sorted({word.strip().lower() for word in data.splitlines()}) UpperCamelCase__ : Optional[int] = collections.defaultdict(list) for word in word_list: word_by_signature[signature(word)].append(word) if __name__ == "__main__": UpperCamelCase__ : List[Any] = {word: anagram(word) for word in word_list if len(anagram(word)) > 1} with open("""anagrams.txt""", """w""") as file: file.write("""all_anagrams = \n """) file.write(pprint.pformat(all_anagrams))
363
from __future__ import annotations import os from collections.abc import Mapping UpperCamelCase__ : Any = tuple[int, int] class lowerCamelCase_ : def __init__( self : Optional[Any] ,__lowerCamelCase : set[int] ,__lowerCamelCase : Mapping[EdgeT, int] ): '''simple docstring''' a = vertices a = { (min(__lowerCamelCase ), max(__lowerCamelCase )): weight for edge, weight in edges.items() } def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : EdgeT ,__lowerCamelCase : int ): '''simple docstring''' self.vertices.add(edge[0] ) self.vertices.add(edge[1] ) a = weight def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' a = Graph({min(self.vertices )} ,{} ) a = 42 a = 42 a = 42 a = 42 while len(subgraph.vertices ) < len(self.vertices ): a = max(self.edges.values() ) + 1 for edge, weight in self.edges.items(): if (edge[0] in subgraph.vertices) ^ (edge[1] in subgraph.vertices): if weight < min_weight: a = edge a = weight subgraph.add_edge(__lowerCamelCase ,__lowerCamelCase ) return subgraph def SCREAMING_SNAKE_CASE__ ( snake_case_ = "p107_network.txt" ) -> int: """simple docstring""" a = os.path.abspath(os.path.dirname(snake_case_ ) ) a = os.path.join(snake_case_, snake_case_ ) a = {} a = 42 a = 42 a = 42 with open(snake_case_ ) as f: a = f.read().strip().split('''\n''' ) a = [line.split(''',''' ) for line in data] for edgea in range(1, len(snake_case_ ) ): for edgea in range(snake_case_ ): if adjaceny_matrix[edgea][edgea] != "-": a = int(adjaceny_matrix[edgea][edgea] ) a = Graph(set(range(len(snake_case_ ) ) ), snake_case_ ) a = graph.prims_algorithm() a = sum(graph.edges.values() ) a = sum(subgraph.edges.values() ) return initial_total - optimal_total if __name__ == "__main__": print(F"{solution() = }")
330
0
import json import os import tempfile import transformers import datasets from utils import generate_example_dataset, get_duration UpperCamelCase__ : Tuple = 500_000 UpperCamelCase__ , UpperCamelCase__ : List[str] = os.path.split(__file__) UpperCamelCase__ : Tuple = os.path.join(RESULTS_BASEPATH, """results""", RESULTS_FILENAME.replace(""".py""", """.json""")) @get_duration def SCREAMING_SNAKE_CASE__ ( snake_case_, **snake_case_ ) -> Union[str, Any]: """simple docstring""" a = dataset.map(**a_ ) @get_duration def SCREAMING_SNAKE_CASE__ ( snake_case_, **snake_case_ ) -> List[str]: """simple docstring""" a = dataset.filter(**a_ ) def SCREAMING_SNAKE_CASE__ ( ) -> Any: """simple docstring""" a = {'''num examples''': SPEED_TEST_N_EXAMPLES} with tempfile.TemporaryDirectory() as tmp_dir: a = datasets.Features({'''text''': datasets.Value('''string''' ), '''numbers''': datasets.Value('''float32''' )} ) a = generate_example_dataset( os.path.join(a_, '''dataset.arrow''' ), a_, num_examples=a_ ) a = transformers.AutoTokenizer.from_pretrained('''bert-base-cased''', use_fast=a_ ) def tokenize(snake_case_ ): return tokenizer(examples['''text'''] ) a = map(a_ ) a = map(a_, batched=a_ ) a = map(a_, function=lambda snake_case_ : None, batched=a_ ) with dataset.formatted_as(type='''numpy''' ): a = map(a_, function=lambda snake_case_ : None, batched=a_ ) with dataset.formatted_as(type='''pandas''' ): a = map(a_, function=lambda snake_case_ : None, batched=a_ ) with dataset.formatted_as(type='''torch''', columns='''numbers''' ): a = map(a_, function=lambda snake_case_ : None, batched=a_ ) with dataset.formatted_as(type='''tensorflow''', columns='''numbers''' ): a = map(a_, function=lambda snake_case_ : None, batched=a_ ) a = map(a_, function=a_, batched=a_ ) a = filter(a_ ) # Activate later when tokenizer support batched inputs # with dataset.formatted_as(type='numpy'): # times[func.__name__ + " fast-tokenizer batched numpy"] = func(dataset, function=tokenize, batched=True) with open(a_, '''wb''' ) as f: f.write(json.dumps(a_ ).encode('''utf-8''' ) ) if __name__ == "__main__": # useful to run the profiler benchmark_map_filter()
364
from typing import Optional, Tuple, Union import tensorflow as tf from ...activations_tf import ACTaFN from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward from ...modeling_tf_outputs import ( TFBaseModelOutputWithNoAttention, TFBaseModelOutputWithPoolingAndNoAttention, TFSequenceClassifierOutput, ) from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs from ...tf_utils import shape_list from ...utils import logging from .configuration_regnet import RegNetConfig UpperCamelCase__ : List[Any] = logging.get_logger(__name__) # General docstring UpperCamelCase__ : List[Any] = """RegNetConfig""" # Base docstring UpperCamelCase__ : Dict = """facebook/regnet-y-040""" UpperCamelCase__ : int = [1, 1_088, 7, 7] # Image classification docstring UpperCamelCase__ : Optional[Any] = """facebook/regnet-y-040""" UpperCamelCase__ : Dict = """tabby, tabby cat""" UpperCamelCase__ : Dict = [ """facebook/regnet-y-040""", # See all regnet models at https://huggingface.co/models?filter=regnet ] class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : List[str] ,__lowerCamelCase : int ,__lowerCamelCase : int = 3 ,__lowerCamelCase : int = 1 ,__lowerCamelCase : int = 1 ,__lowerCamelCase : Optional[str] = "relu" ,**__lowerCamelCase : str ,): '''simple docstring''' super().__init__(**__lowerCamelCase ) # The padding and conv has been verified in # https://colab.research.google.com/gist/sayakpaul/854bc10eeaf21c9ee2119e0b9f3841a7/scratchpad.ipynb a = tf.keras.layers.ZeroPaddingaD(padding=kernel_size // 2 ) a = tf.keras.layers.ConvaD( filters=__lowerCamelCase ,kernel_size=__lowerCamelCase ,strides=__lowerCamelCase ,padding='''VALID''' ,groups=__lowerCamelCase ,use_bias=__lowerCamelCase ,name='''convolution''' ,) a = tf.keras.layers.BatchNormalization(epsilon=1e-5 ,momentum=0.9 ,name='''normalization''' ) a = ACTaFN[activation] if activation is not None else tf.identity def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : List[str] ): '''simple docstring''' a = self.convolution(self.padding(__lowerCamelCase ) ) a = self.normalization(__lowerCamelCase ) a = self.activation(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Any ,__lowerCamelCase : RegNetConfig ,**__lowerCamelCase : List[Any] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = config.num_channels a = TFRegNetConvLayer( out_channels=config.embedding_size ,kernel_size=3 ,stride=2 ,activation=config.hidden_act ,name='''embedder''' ,) def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : Optional[Any] ): '''simple docstring''' a = shape_list(__lowerCamelCase )[1] if tf.executing_eagerly() and 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.''' ) # When running on CPU, `tf.keras.layers.Conv2D` doesn't support `NCHW` format. # So change the input format from `NCHW` to `NHWC`. # shape = (batch_size, in_height, in_width, in_channels=num_channels) a = tf.transpose(__lowerCamelCase ,perm=(0, 2, 3, 1) ) a = self.embedder(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : str ,__lowerCamelCase : int ,__lowerCamelCase : int = 2 ,**__lowerCamelCase : Tuple ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = tf.keras.layers.ConvaD( filters=__lowerCamelCase ,kernel_size=1 ,strides=__lowerCamelCase ,use_bias=__lowerCamelCase ,name='''convolution''' ) a = tf.keras.layers.BatchNormalization(epsilon=1e-5 ,momentum=0.9 ,name='''normalization''' ) def SCREAMING_SNAKE_CASE_ ( self : Dict ,__lowerCamelCase : tf.Tensor ,__lowerCamelCase : bool = False ): '''simple docstring''' return self.normalization(self.convolution(__lowerCamelCase ) ,training=__lowerCamelCase ) class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : List[Any] ,__lowerCamelCase : int ,__lowerCamelCase : int ,**__lowerCamelCase : str ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = tf.keras.layers.GlobalAveragePoolingaD(keepdims=__lowerCamelCase ,name='''pooler''' ) a = [ tf.keras.layers.ConvaD(filters=__lowerCamelCase ,kernel_size=1 ,activation='''relu''' ,name='''attention.0''' ), tf.keras.layers.ConvaD(filters=__lowerCamelCase ,kernel_size=1 ,activation='''sigmoid''' ,name='''attention.2''' ), ] def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : Optional[Any] ): '''simple docstring''' a = self.pooler(__lowerCamelCase ) for layer_module in self.attention: a = layer_module(__lowerCamelCase ) a = hidden_state * pooled return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Union[str, Any] ,__lowerCamelCase : RegNetConfig ,__lowerCamelCase : int ,__lowerCamelCase : int ,__lowerCamelCase : int = 1 ,**__lowerCamelCase : Dict ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = in_channels != out_channels or stride != 1 a = max(1 ,out_channels // config.groups_width ) a = ( TFRegNetShortCut(__lowerCamelCase ,stride=__lowerCamelCase ,name='''shortcut''' ) if should_apply_shortcut else tf.keras.layers.Activation('''linear''' ,name='''shortcut''' ) ) # `self.layers` instead of `self.layer` because that is a reserved argument. a = [ TFRegNetConvLayer(__lowerCamelCase ,kernel_size=1 ,activation=config.hidden_act ,name='''layer.0''' ), TFRegNetConvLayer( __lowerCamelCase ,stride=__lowerCamelCase ,groups=__lowerCamelCase ,activation=config.hidden_act ,name='''layer.1''' ), TFRegNetConvLayer(__lowerCamelCase ,kernel_size=1 ,activation=__lowerCamelCase ,name='''layer.2''' ), ] a = ACTaFN[config.hidden_act] def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = hidden_state for layer_module in self.layers: a = layer_module(__lowerCamelCase ) a = self.shortcut(__lowerCamelCase ) hidden_state += residual a = self.activation(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Dict ,__lowerCamelCase : RegNetConfig ,__lowerCamelCase : int ,__lowerCamelCase : int ,__lowerCamelCase : int = 1 ,**__lowerCamelCase : List[str] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = in_channels != out_channels or stride != 1 a = max(1 ,out_channels // config.groups_width ) a = ( TFRegNetShortCut(__lowerCamelCase ,stride=__lowerCamelCase ,name='''shortcut''' ) if should_apply_shortcut else tf.keras.layers.Activation('''linear''' ,name='''shortcut''' ) ) a = [ TFRegNetConvLayer(__lowerCamelCase ,kernel_size=1 ,activation=config.hidden_act ,name='''layer.0''' ), TFRegNetConvLayer( __lowerCamelCase ,stride=__lowerCamelCase ,groups=__lowerCamelCase ,activation=config.hidden_act ,name='''layer.1''' ), TFRegNetSELayer(__lowerCamelCase ,reduced_channels=int(round(in_channels / 4 ) ) ,name='''layer.2''' ), TFRegNetConvLayer(__lowerCamelCase ,kernel_size=1 ,activation=__lowerCamelCase ,name='''layer.3''' ), ] a = ACTaFN[config.hidden_act] def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ,__lowerCamelCase : str ): '''simple docstring''' a = hidden_state for layer_module in self.layers: a = layer_module(__lowerCamelCase ) a = self.shortcut(__lowerCamelCase ) hidden_state += residual a = self.activation(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Optional[int] ,__lowerCamelCase : RegNetConfig ,__lowerCamelCase : int ,__lowerCamelCase : int ,__lowerCamelCase : int = 2 ,__lowerCamelCase : int = 2 ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = TFRegNetXLayer if config.layer_type == '''x''' else TFRegNetYLayer a = [ # downsampling is done in the first layer with stride of 2 layer(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ,stride=__lowerCamelCase ,name='''layers.0''' ), *[layer(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ,name=F"""layers.{i+1}""" ) for i in range(depth - 1 )], ] def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : int ): '''simple docstring''' for layer_module in self.layers: a = layer_module(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Union[str, Any] ,__lowerCamelCase : RegNetConfig ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = [] # based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input self.stages.append( TFRegNetStage( __lowerCamelCase ,config.embedding_size ,config.hidden_sizes[0] ,stride=2 if config.downsample_in_first_stage else 1 ,depth=config.depths[0] ,name='''stages.0''' ,) ) a = zip(config.hidden_sizes ,config.hidden_sizes[1:] ) for i, ((in_channels, out_channels), depth) in enumerate(zip(__lowerCamelCase ,config.depths[1:] ) ): self.stages.append(TFRegNetStage(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ,depth=__lowerCamelCase ,name=F"""stages.{i+1}""" ) ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : tf.Tensor ,__lowerCamelCase : bool = False ,__lowerCamelCase : bool = True ): '''simple docstring''' 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(__lowerCamelCase ) 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 TFBaseModelOutputWithNoAttention(last_hidden_state=__lowerCamelCase ,hidden_states=__lowerCamelCase ) @keras_serializable class lowerCamelCase_ ( tf.keras.layers.Layer ): SCREAMING_SNAKE_CASE_ = RegNetConfig def __init__( self : Dict ,__lowerCamelCase : Optional[int] ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = config a = TFRegNetEmbeddings(__lowerCamelCase ,name='''embedder''' ) a = TFRegNetEncoder(__lowerCamelCase ,name='''encoder''' ) a = tf.keras.layers.GlobalAveragePoolingaD(keepdims=__lowerCamelCase ,name='''pooler''' ) @unpack_inputs def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : tf.Tensor ,__lowerCamelCase : Optional[bool] = None ,__lowerCamelCase : Optional[bool] = None ,__lowerCamelCase : bool = False ,): '''simple docstring''' a = ( output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states ) a = return_dict if return_dict is not None else self.config.use_return_dict a = self.embedder(__lowerCamelCase ,training=__lowerCamelCase ) a = self.encoder( __lowerCamelCase ,output_hidden_states=__lowerCamelCase ,return_dict=__lowerCamelCase ,training=__lowerCamelCase ) a = encoder_outputs[0] a = self.pooler(__lowerCamelCase ) # Change to NCHW output format have uniformity in the modules a = tf.transpose(__lowerCamelCase ,perm=(0, 3, 1, 2) ) a = tf.transpose(__lowerCamelCase ,perm=(0, 3, 1, 2) ) # Change the other hidden state outputs to NCHW as well if output_hidden_states: a = tuple([tf.transpose(__lowerCamelCase ,perm=(0, 3, 1, 2) ) for h in encoder_outputs[1]] ) if not return_dict: return (last_hidden_state, pooled_output) + encoder_outputs[1:] return TFBaseModelOutputWithPoolingAndNoAttention( last_hidden_state=__lowerCamelCase ,pooler_output=__lowerCamelCase ,hidden_states=hidden_states if output_hidden_states else encoder_outputs.hidden_states ,) class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = RegNetConfig SCREAMING_SNAKE_CASE_ = 'regnet' SCREAMING_SNAKE_CASE_ = 'pixel_values' @property def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 2_24, 2_24) ,dtype=tf.floataa )} UpperCamelCase__ : Union[str, Any] = R""" Parameters: This model is a Tensorflow [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a regular Tensorflow Module and refer to the Tensorflow documentation for all matter related to general usage and behavior. config ([`RegNetConfig`]): 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 [`~TFPreTrainedModel.from_pretrained`] method to load the model weights. """ UpperCamelCase__ : List[str] = R""" Args: pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`): Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See [`ConveNextImageProcessor.__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 RegNet model outputting raw features without any specific head on top.' , a_ , ) class lowerCamelCase_ ( a_ ): def __init__( self : Optional[int] ,__lowerCamelCase : RegNetConfig ,*__lowerCamelCase : int ,**__lowerCamelCase : Union[str, Any] ): '''simple docstring''' super().__init__(__lowerCamelCase ,*__lowerCamelCase ,**__lowerCamelCase ) a = TFRegNetMainLayer(__lowerCamelCase ,name='''regnet''' ) @unpack_inputs @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 SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : tf.Tensor ,__lowerCamelCase : Optional[bool] = None ,__lowerCamelCase : Optional[bool] = None ,__lowerCamelCase : List[str]=False ,): '''simple docstring''' a = ( output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states ) a = return_dict if return_dict is not None else self.config.use_return_dict a = self.regnet( pixel_values=__lowerCamelCase ,output_hidden_states=__lowerCamelCase ,return_dict=__lowerCamelCase ,training=__lowerCamelCase ,) if not return_dict: return (outputs[0],) + outputs[1:] return TFBaseModelOutputWithPoolingAndNoAttention( last_hidden_state=outputs.last_hidden_state ,pooler_output=outputs.pooler_output ,hidden_states=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 ' , a_ , ) class lowerCamelCase_ ( a_ , a_ ): def __init__( self : Optional[int] ,__lowerCamelCase : RegNetConfig ,*__lowerCamelCase : str ,**__lowerCamelCase : Any ): '''simple docstring''' super().__init__(__lowerCamelCase ,*__lowerCamelCase ,**__lowerCamelCase ) a = config.num_labels a = TFRegNetMainLayer(__lowerCamelCase ,name='''regnet''' ) # classification head a = [ tf.keras.layers.Flatten(), tf.keras.layers.Dense(config.num_labels ,name='''classifier.1''' ) if config.num_labels > 0 else tf.identity, ] @unpack_inputs @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 SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : tf.Tensor = None ,__lowerCamelCase : tf.Tensor = None ,__lowerCamelCase : bool = None ,__lowerCamelCase : bool = None ,__lowerCamelCase : Dict=False ,): '''simple docstring''' a = ( output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states ) a = return_dict if return_dict is not None else self.config.use_return_dict a = self.regnet( __lowerCamelCase ,output_hidden_states=__lowerCamelCase ,return_dict=__lowerCamelCase ,training=__lowerCamelCase ) a = outputs.pooler_output if return_dict else outputs[1] a = self.classifier[0](__lowerCamelCase ) a = self.classifier[1](__lowerCamelCase ) a = None if labels is None else self.hf_compute_loss(labels=__lowerCamelCase ,logits=__lowerCamelCase ) if not return_dict: a = (logits,) + outputs[2:] return ((loss,) + output) if loss is not None else output return TFSequenceClassifierOutput(loss=__lowerCamelCase ,logits=__lowerCamelCase ,hidden_states=outputs.hidden_states )
330
0
from ...utils import ( OptionalDependencyNotAvailable, is_flax_available, is_torch_available, is_transformers_available, ) 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 .multicontrolnet import MultiControlNetModel from .pipeline_controlnet import StableDiffusionControlNetPipeline from .pipeline_controlnet_imgaimg import StableDiffusionControlNetImgaImgPipeline from .pipeline_controlnet_inpaint import StableDiffusionControlNetInpaintPipeline if is_transformers_available() and is_flax_available(): from .pipeline_flax_controlnet import FlaxStableDiffusionControlNetPipeline
365
from typing import List from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCamelCase__ : Union[str, Any] = logging.get_logger(__name__) UpperCamelCase__ : List[str] = { """snap-research/efficientformer-l1-300""": ( """https://huggingface.co/snap-research/efficientformer-l1-300/resolve/main/config.json""" ), } class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = 'efficientformer' def __init__( self : Optional[int] ,__lowerCamelCase : List[int] = [3, 2, 6, 4] ,__lowerCamelCase : List[int] = [48, 96, 2_24, 4_48] ,__lowerCamelCase : List[bool] = [True, True, True, True] ,__lowerCamelCase : int = 4_48 ,__lowerCamelCase : int = 32 ,__lowerCamelCase : int = 4 ,__lowerCamelCase : int = 7 ,__lowerCamelCase : int = 5 ,__lowerCamelCase : int = 8 ,__lowerCamelCase : int = 4 ,__lowerCamelCase : float = 0.0 ,__lowerCamelCase : int = 16 ,__lowerCamelCase : int = 3 ,__lowerCamelCase : int = 3 ,__lowerCamelCase : int = 3 ,__lowerCamelCase : int = 2 ,__lowerCamelCase : int = 1 ,__lowerCamelCase : float = 0.0 ,__lowerCamelCase : int = 1 ,__lowerCamelCase : bool = True ,__lowerCamelCase : bool = True ,__lowerCamelCase : float = 1e-5 ,__lowerCamelCase : str = "gelu" ,__lowerCamelCase : float = 0.02 ,__lowerCamelCase : float = 1e-12 ,__lowerCamelCase : int = 2_24 ,__lowerCamelCase : float = 1e-05 ,**__lowerCamelCase : Dict ,): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = hidden_act a = hidden_dropout_prob a = hidden_sizes a = num_hidden_layers a = num_attention_heads a = initializer_range a = layer_norm_eps a = patch_size a = num_channels a = depths a = mlp_expansion_ratio a = downsamples a = dim a = key_dim a = attention_ratio a = resolution a = pool_size a = downsample_patch_size a = downsample_stride a = downsample_pad a = drop_path_rate a = num_metaad_blocks a = distillation a = use_layer_scale a = layer_scale_init_value a = image_size a = batch_norm_eps
330
0
import shutil import tempfile import unittest from unittest.mock import patch from transformers import ( DefaultFlowCallback, IntervalStrategy, PrinterCallback, ProgressCallback, Trainer, TrainerCallback, TrainingArguments, is_torch_available, ) from transformers.testing_utils import require_torch if is_torch_available(): from transformers.trainer import DEFAULT_CALLBACKS from .test_trainer import RegressionDataset, RegressionModelConfig, RegressionPreTrainedModel class lowerCamelCase_ ( __SCREAMING_SNAKE_CASE ): def __init__( self : str ): '''simple docstring''' a = [] def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : str ,__lowerCamelCase : List[str] ,__lowerCamelCase : Tuple ,**__lowerCamelCase : str ): '''simple docstring''' self.events.append('''on_init_end''' ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : Any ,__lowerCamelCase : Optional[int] ,__lowerCamelCase : int ,**__lowerCamelCase : int ): '''simple docstring''' self.events.append('''on_train_begin''' ) def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : Union[str, Any] ,__lowerCamelCase : Union[str, Any] ,**__lowerCamelCase : int ): '''simple docstring''' self.events.append('''on_train_end''' ) def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ,__lowerCamelCase : Union[str, Any] ,__lowerCamelCase : str ,__lowerCamelCase : Optional[Any] ,**__lowerCamelCase : Union[str, Any] ): '''simple docstring''' self.events.append('''on_epoch_begin''' ) def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ,__lowerCamelCase : Tuple ,__lowerCamelCase : Any ,__lowerCamelCase : int ,**__lowerCamelCase : int ): '''simple docstring''' self.events.append('''on_epoch_end''' ) def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : str ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : Optional[Any] ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' self.events.append('''on_step_begin''' ) def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : int ,__lowerCamelCase : List[str] ,__lowerCamelCase : Any ,**__lowerCamelCase : str ): '''simple docstring''' self.events.append('''on_step_end''' ) def SCREAMING_SNAKE_CASE_ ( self : Dict ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : int ,__lowerCamelCase : str ,**__lowerCamelCase : List[Any] ): '''simple docstring''' self.events.append('''on_evaluate''' ) def SCREAMING_SNAKE_CASE_ ( self : Dict ,__lowerCamelCase : str ,__lowerCamelCase : int ,__lowerCamelCase : str ,**__lowerCamelCase : Tuple ): '''simple docstring''' self.events.append('''on_predict''' ) def SCREAMING_SNAKE_CASE_ ( self : List[Any] ,__lowerCamelCase : Dict ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : Optional[Any] ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' self.events.append('''on_save''' ) def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : Any ,__lowerCamelCase : str ,__lowerCamelCase : List[Any] ,**__lowerCamelCase : Any ): '''simple docstring''' self.events.append('''on_log''' ) def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : Tuple ,__lowerCamelCase : Any ,__lowerCamelCase : Any ,**__lowerCamelCase : Union[str, Any] ): '''simple docstring''' self.events.append('''on_prediction_step''' ) @require_torch class lowerCamelCase_ ( unittest.TestCase ): def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' a = tempfile.mkdtemp() def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' shutil.rmtree(self.output_dir ) def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ,__lowerCamelCase : Any=0 ,__lowerCamelCase : Optional[int]=0 ,__lowerCamelCase : List[str]=64 ,__lowerCamelCase : List[Any]=64 ,__lowerCamelCase : Union[str, Any]=None ,__lowerCamelCase : List[str]=False ,**__lowerCamelCase : Optional[int] ): '''simple docstring''' a = RegressionDataset(length=__UpperCAmelCase ) a = RegressionDataset(length=__UpperCAmelCase ) a = RegressionModelConfig(a=__UpperCAmelCase ,b=__UpperCAmelCase ) a = RegressionPreTrainedModel(__UpperCAmelCase ) a = TrainingArguments(self.output_dir ,disable_tqdm=__UpperCAmelCase ,report_to=[] ,**__UpperCAmelCase ) return Trainer( __UpperCAmelCase ,__UpperCAmelCase ,train_dataset=__UpperCAmelCase ,eval_dataset=__UpperCAmelCase ,callbacks=__UpperCAmelCase ,) def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : Dict ,__lowerCamelCase : Optional[int] ): '''simple docstring''' self.assertEqual(len(__UpperCAmelCase ) ,len(__UpperCAmelCase ) ) # Order doesn't matter a = sorted(__UpperCAmelCase ,key=lambda __lowerCamelCase : cb.__name__ if isinstance(__UpperCAmelCase ,__UpperCAmelCase ) else cb.__class__.__name__ ) a = sorted(__UpperCAmelCase ,key=lambda __lowerCamelCase : cb.__name__ if isinstance(__UpperCAmelCase ,__UpperCAmelCase ) else cb.__class__.__name__ ) for cba, cba in zip(__UpperCAmelCase ,__UpperCAmelCase ): if isinstance(__UpperCAmelCase ,__UpperCAmelCase ) and isinstance(__UpperCAmelCase ,__UpperCAmelCase ): self.assertEqual(__UpperCAmelCase ,__UpperCAmelCase ) elif isinstance(__UpperCAmelCase ,__UpperCAmelCase ) and not isinstance(__UpperCAmelCase ,__UpperCAmelCase ): self.assertEqual(__UpperCAmelCase ,cba.__class__ ) elif not isinstance(__UpperCAmelCase ,__UpperCAmelCase ) and isinstance(__UpperCAmelCase ,__UpperCAmelCase ): self.assertEqual(cba.__class__ ,__UpperCAmelCase ) else: self.assertEqual(__UpperCAmelCase ,__UpperCAmelCase ) def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ,__lowerCamelCase : List[str] ): '''simple docstring''' a = ["""on_init_end""", """on_train_begin"""] a = 0 a = len(trainer.get_eval_dataloader() ) a = ["""on_prediction_step"""] * len(trainer.get_eval_dataloader() ) + ["""on_log""", """on_evaluate"""] for _ in range(trainer.state.num_train_epochs ): expected_events.append('''on_epoch_begin''' ) for _ in range(__UpperCAmelCase ): step += 1 expected_events += ["on_step_begin", "on_step_end"] if step % trainer.args.logging_steps == 0: expected_events.append('''on_log''' ) if trainer.args.evaluation_strategy == IntervalStrategy.STEPS and step % trainer.args.eval_steps == 0: expected_events += evaluation_events.copy() if step % trainer.args.save_steps == 0: expected_events.append('''on_save''' ) expected_events.append('''on_epoch_end''' ) if trainer.args.evaluation_strategy == IntervalStrategy.EPOCH: expected_events += evaluation_events.copy() expected_events += ["on_log", "on_train_end"] return expected_events def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ): '''simple docstring''' a = self.get_trainer() a = DEFAULT_CALLBACKS.copy() + [ProgressCallback] self.check_callbacks_equality(trainer.callback_handler.callbacks ,__UpperCAmelCase ) # Callbacks passed at init are added to the default callbacks a = self.get_trainer(callbacks=[MyTestTrainerCallback] ) expected_callbacks.append(__UpperCAmelCase ) self.check_callbacks_equality(trainer.callback_handler.callbacks ,__UpperCAmelCase ) # TrainingArguments.disable_tqdm controls if use ProgressCallback or PrinterCallback a = self.get_trainer(disable_tqdm=__UpperCAmelCase ) a = DEFAULT_CALLBACKS.copy() + [PrinterCallback] self.check_callbacks_equality(trainer.callback_handler.callbacks ,__UpperCAmelCase ) def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' a = DEFAULT_CALLBACKS.copy() + [ProgressCallback] a = self.get_trainer() # We can add, pop, or remove by class name trainer.remove_callback(__UpperCAmelCase ) expected_callbacks.remove(__UpperCAmelCase ) self.check_callbacks_equality(trainer.callback_handler.callbacks ,__UpperCAmelCase ) a = self.get_trainer() a = trainer.pop_callback(__UpperCAmelCase ) self.assertEqual(cb.__class__ ,__UpperCAmelCase ) self.check_callbacks_equality(trainer.callback_handler.callbacks ,__UpperCAmelCase ) trainer.add_callback(__UpperCAmelCase ) expected_callbacks.insert(0 ,__UpperCAmelCase ) self.check_callbacks_equality(trainer.callback_handler.callbacks ,__UpperCAmelCase ) # We can also add, pop, or remove by instance a = self.get_trainer() a = trainer.callback_handler.callbacks[0] trainer.remove_callback(__UpperCAmelCase ) expected_callbacks.remove(__UpperCAmelCase ) self.check_callbacks_equality(trainer.callback_handler.callbacks ,__UpperCAmelCase ) a = self.get_trainer() a = trainer.callback_handler.callbacks[0] a = trainer.pop_callback(__UpperCAmelCase ) self.assertEqual(__UpperCAmelCase ,__UpperCAmelCase ) self.check_callbacks_equality(trainer.callback_handler.callbacks ,__UpperCAmelCase ) trainer.add_callback(__UpperCAmelCase ) expected_callbacks.insert(0 ,__UpperCAmelCase ) self.check_callbacks_equality(trainer.callback_handler.callbacks ,__UpperCAmelCase ) def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' import warnings # XXX: for now ignore scatter_gather warnings in this test since it's not relevant to what's being tested warnings.simplefilter(action='''ignore''' ,category=__UpperCAmelCase ) a = self.get_trainer(callbacks=[MyTestTrainerCallback] ) trainer.train() a = trainer.callback_handler.callbacks[-2].events self.assertEqual(__UpperCAmelCase ,self.get_expected_events(__UpperCAmelCase ) ) # Independent log/save/eval a = self.get_trainer(callbacks=[MyTestTrainerCallback] ,logging_steps=5 ) trainer.train() a = trainer.callback_handler.callbacks[-2].events self.assertEqual(__UpperCAmelCase ,self.get_expected_events(__UpperCAmelCase ) ) a = self.get_trainer(callbacks=[MyTestTrainerCallback] ,save_steps=5 ) trainer.train() a = trainer.callback_handler.callbacks[-2].events self.assertEqual(__UpperCAmelCase ,self.get_expected_events(__UpperCAmelCase ) ) a = self.get_trainer(callbacks=[MyTestTrainerCallback] ,eval_steps=5 ,evaluation_strategy='''steps''' ) trainer.train() a = trainer.callback_handler.callbacks[-2].events self.assertEqual(__UpperCAmelCase ,self.get_expected_events(__UpperCAmelCase ) ) a = self.get_trainer(callbacks=[MyTestTrainerCallback] ,evaluation_strategy='''epoch''' ) trainer.train() a = trainer.callback_handler.callbacks[-2].events self.assertEqual(__UpperCAmelCase ,self.get_expected_events(__UpperCAmelCase ) ) # A bit of everything a = self.get_trainer( callbacks=[MyTestTrainerCallback] ,logging_steps=3 ,save_steps=10 ,eval_steps=5 ,evaluation_strategy='''steps''' ,) trainer.train() a = trainer.callback_handler.callbacks[-2].events self.assertEqual(__UpperCAmelCase ,self.get_expected_events(__UpperCAmelCase ) ) # warning should be emitted for duplicated callbacks with patch('''transformers.trainer_callback.logger.warning''' ) as warn_mock: a = self.get_trainer( callbacks=[MyTestTrainerCallback, MyTestTrainerCallback] ,) assert str(__UpperCAmelCase ) in warn_mock.call_args[0][0]
366
import argparse from typing import Dict import tensorflow as tf import torch from tqdm import tqdm from transformers import BigBirdPegasusConfig, BigBirdPegasusForConditionalGeneration UpperCamelCase__ : Any = [ # tf -> hf ("""/""", """."""), ("""layer_""", """layers."""), ("""kernel""", """weight"""), ("""beta""", """bias"""), ("""gamma""", """weight"""), ("""pegasus""", """model"""), ] UpperCamelCase__ : Optional[Any] = [ (""".output.dense""", """.fc2"""), ("""intermediate.LayerNorm""", """final_layer_norm"""), ("""intermediate.dense""", """fc1"""), ] UpperCamelCase__ : Optional[Any] = ( INIT_COMMON + [ ("""attention.self.LayerNorm""", """self_attn_layer_norm"""), ("""attention.output.dense""", """self_attn.out_proj"""), ("""attention.self""", """self_attn"""), ("""attention.encdec.LayerNorm""", """encoder_attn_layer_norm"""), ("""attention.encdec_output.dense""", """encoder_attn.out_proj"""), ("""attention.encdec""", """encoder_attn"""), ("""key""", """k_proj"""), ("""value""", """v_proj"""), ("""query""", """q_proj"""), ("""decoder.LayerNorm""", """decoder.layernorm_embedding"""), ] + END_COMMON ) UpperCamelCase__ : List[str] = ( INIT_COMMON + [ ("""embeddings.word_embeddings""", """shared.weight"""), ("""embeddings.position_embeddings""", """embed_positions.weight"""), ("""attention.self.LayerNorm""", """self_attn_layer_norm"""), ("""attention.output.dense""", """self_attn.output"""), ("""attention.self""", """self_attn.self"""), ("""encoder.LayerNorm""", """encoder.layernorm_embedding"""), ] + END_COMMON ) UpperCamelCase__ : Optional[int] = [ """encdec/key/bias""", """encdec/query/bias""", """encdec/value/bias""", """self/key/bias""", """self/query/bias""", """self/value/bias""", """encdec_output/dense/bias""", """attention/output/dense/bias""", ] def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> List[Any]: """simple docstring""" for tf_name, hf_name in patterns: a = k.replace(snake_case_, snake_case_ ) return k def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> BigBirdPegasusForConditionalGeneration: """simple docstring""" a = BigBirdPegasusConfig(**snake_case_ ) a = BigBirdPegasusForConditionalGeneration(snake_case_ ) a = torch_model.state_dict() a = {} # separating decoder weights a = {k: tf_weights[k] for k in tf_weights if k.startswith('''pegasus/decoder''' )} a = {k: tf_weights[k] for k in tf_weights if not k.startswith('''pegasus/decoder''' )} for k, v in tqdm(decoder_weights.items(), '''tf -> hf conversion''' ): a = [k.endswith(snake_case_ ) for ending in KEYS_TO_IGNORE] if any(snake_case_ ): continue a = DECODER_PATTERNS a = rename_state_dict_key(snake_case_, snake_case_ ) if new_k not in state_dict: raise ValueError(f"""could not find new key {new_k} in state dict. (converted from {k})""" ) if any(True if i in k else False for i in ['''dense''', '''query''', '''key''', '''value'''] ): a = v.T a = torch.from_numpy(snake_case_ ) assert v.shape == state_dict[new_k].shape, f"""{new_k}, {k}, {v.shape}, {state_dict[new_k].shape}""" for k, v in tqdm(remaining_weights.items(), '''tf -> hf conversion''' ): a = [k.endswith(snake_case_ ) for ending in KEYS_TO_IGNORE] if any(snake_case_ ): continue a = REMAINING_PATTERNS a = rename_state_dict_key(snake_case_, snake_case_ ) if new_k not in state_dict and k != "pegasus/embeddings/position_embeddings": raise ValueError(f"""could not find new key {new_k} in state dict. (converted from {k})""" ) if any(True if i in k else False for i in ['''dense''', '''query''', '''key''', '''value'''] ): a = v.T a = torch.from_numpy(snake_case_ ) if k != "pegasus/embeddings/position_embeddings": assert v.shape == state_dict[new_k].shape, f"""{new_k}, {k}, {v.shape}, {state_dict[new_k].shape}""" a = mapping['''model.embed_positions.weight'''] a = mapping.pop('''model.embed_positions.weight''' ) a , a = torch_model.load_state_dict(snake_case_, strict=snake_case_ ) a = [ k for k in missing if k not in [ '''final_logits_bias''', '''model.encoder.embed_tokens.weight''', '''model.decoder.embed_tokens.weight''', '''lm_head.weight''', ] ] assert unexpected_missing == [], f"""no matches found for the following torch keys {unexpected_missing}""" assert extra == [], f"""no matches found for the following tf keys {extra}""" return torch_model def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Dict: """simple docstring""" a = tf.train.list_variables(snake_case_ ) a = {} a = ['''global_step'''] for name, shape in tqdm(snake_case_, desc='''converting tf checkpoint to dict''' ): a = any(pat in name for pat in ignore_name ) if skip_key: continue a = tf.train.load_variable(snake_case_, snake_case_ ) a = array return tf_weights def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> int: """simple docstring""" a = get_tf_weights_as_numpy(snake_case_ ) a = convert_bigbird_pegasus(snake_case_, snake_case_ ) torch_model.save_pretrained(snake_case_ ) if __name__ == "__main__": UpperCamelCase__ : str = argparse.ArgumentParser() parser.add_argument("""--tf_ckpt_path""", type=str, help="""passed to tf.train.list_variables""") parser.add_argument("""--save_dir""", default=None, type=str, help="""Path to the output PyTorch model.""") UpperCamelCase__ : int = parser.parse_args() UpperCamelCase__ : Tuple = {} convert_bigbird_pegasus_ckpt_to_pytorch(args.tf_ckpt_path, args.save_dir, config_update=config_update)
330
0
from .constants import ( MODEL_NAME, OPTIMIZER_NAME, RNG_STATE_NAME, SAFE_WEIGHTS_INDEX_NAME, SAFE_WEIGHTS_NAME, SCALER_NAME, SCHEDULER_NAME, TORCH_LAUNCH_PARAMS, WEIGHTS_INDEX_NAME, WEIGHTS_NAME, ) from .dataclasses import ( BnbQuantizationConfig, ComputeEnvironment, CustomDtype, DeepSpeedPlugin, DistributedDataParallelKwargs, DistributedType, DynamoBackend, FPaRecipeKwargs, FullyShardedDataParallelPlugin, GradientAccumulationPlugin, GradScalerKwargs, InitProcessGroupKwargs, KwargsHandler, LoggerType, MegatronLMPlugin, PrecisionType, ProjectConfiguration, RNGType, SageMakerDistributedType, TensorInformation, TorchDynamoPlugin, ) from .environment import get_int_from_env, parse_choice_from_env, parse_flag_from_env from .imports import ( get_ccl_version, is_abit_bnb_available, is_abit_bnb_available, is_aim_available, is_bfaa_available, is_bnb_available, is_botoa_available, is_ccl_available, is_comet_ml_available, is_datasets_available, is_deepspeed_available, is_fpa_available, is_ipex_available, is_megatron_lm_available, is_mlflow_available, is_mps_available, is_npu_available, is_rich_available, is_safetensors_available, is_sagemaker_available, is_tensorboard_available, is_tpu_available, is_transformers_available, is_wandb_available, is_xpu_available, ) from .modeling import ( check_device_map, check_tied_parameters_in_config, check_tied_parameters_on_same_device, compute_module_sizes, convert_file_size_to_int, dtype_byte_size, find_tied_parameters, get_balanced_memory, get_max_layer_size, get_max_memory, get_mixed_precision_context_manager, id_tensor_storage, infer_auto_device_map, load_checkpoint_in_model, load_offloaded_weights, load_state_dict, named_module_tensors, retie_parameters, set_module_tensor_to_device, shard_checkpoint, ) from .offload import ( OffloadedWeightsLoader, PrefixedDataset, extract_submodules_state_dict, load_offloaded_weight, offload_state_dict, offload_weight, save_offload_index, ) from .operations import ( broadcast, broadcast_object_list, concatenate, convert_outputs_to_fpaa, convert_to_fpaa, find_batch_size, find_device, gather, gather_object, get_data_structure, honor_type, initialize_tensors, is_namedtuple, is_tensor_information, is_torch_tensor, listify, pad_across_processes, recursively_apply, reduce, send_to_device, slice_tensors, ) from .versions import compare_versions, is_torch_version if is_deepspeed_available(): from .deepspeed import ( DeepSpeedEngineWrapper, DeepSpeedOptimizerWrapper, DeepSpeedSchedulerWrapper, DummyOptim, DummyScheduler, HfDeepSpeedConfig, ) from .bnb import has_abit_bnb_layers, load_and_quantize_model from .fsdp_utils import load_fsdp_model, load_fsdp_optimizer, save_fsdp_model, save_fsdp_optimizer from .launch import ( PrepareForLaunch, _filter_args, prepare_deepspeed_cmd_env, prepare_multi_gpu_env, prepare_sagemager_args_inputs, prepare_simple_launcher_cmd_env, prepare_tpu, ) from .megatron_lm import ( AbstractTrainStep, BertTrainStep, GPTTrainStep, MegatronEngine, MegatronLMDummyDataLoader, MegatronLMDummyScheduler, MegatronLMOptimizerWrapper, MegatronLMSchedulerWrapper, TaTrainStep, avg_losses_across_data_parallel_group, gather_across_data_parallel_groups, ) from .megatron_lm import initialize as megatron_lm_initialize from .megatron_lm import prepare_data_loader as megatron_lm_prepare_data_loader from .megatron_lm import prepare_model as megatron_lm_prepare_model from .megatron_lm import prepare_optimizer as megatron_lm_prepare_optimizer from .megatron_lm import prepare_scheduler as megatron_lm_prepare_scheduler from .memory import find_executable_batch_size, release_memory from .other import ( extract_model_from_parallel, get_pretty_name, is_port_in_use, merge_dicts, patch_environment, save, wait_for_everyone, write_basic_config, ) from .random import set_seed, synchronize_rng_state, synchronize_rng_states from .torch_xla import install_xla from .tqdm import tqdm from .transformer_engine import convert_model, has_transformer_engine_layers
367
import re def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> str: """simple docstring""" if len(re.findall('''[ATCG]''', snake_case_ ) ) != len(snake_case_ ): raise ValueError('''Invalid Strand''' ) return dna.translate(dna.maketrans('''ATCG''', '''TAGC''' ) ) if __name__ == "__main__": import doctest doctest.testmod()
330
0
"""simple docstring""" from __future__ import annotations from collections.abc import Iterator class lowerCamelCase_ : def __init__( self : Union[str, Any] ,__lowerCamelCase : str ): '''simple docstring''' a = value a = None a = None class lowerCamelCase_ : def __init__( self : int ,__lowerCamelCase : Dict ): '''simple docstring''' a = tree def SCREAMING_SNAKE_CASE_ ( self : Dict ,__lowerCamelCase : Tuple ): '''simple docstring''' if node is None: return 0 return node.value + ( self.depth_first_search(node.left ) + self.depth_first_search(node.right ) ) def __iter__( self : List[Any] ): '''simple docstring''' yield self.depth_first_search(self.tree ) if __name__ == "__main__": import doctest doctest.testmod()
368
from __future__ import annotations from collections.abc import Sequence from typing import Literal def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> str | Literal[False]: """simple docstring""" a = list(snake_case_ ) a = list(snake_case_ ) a = 0 for i in range(len(snake_case_ ) ): if lista[i] != lista[i]: count += 1 a = '''_''' if count > 1: return False else: return "".join(snake_case_ ) def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> list[str]: """simple docstring""" a = [] while True: a = ['''$'''] * len(snake_case_ ) a = [] for i in range(len(snake_case_ ) ): for j in range(i + 1, len(snake_case_ ) ): a = compare_string(binary[i], binary[j] ) if k is False: a = '''*''' a = '''*''' temp.append('''X''' ) for i in range(len(snake_case_ ) ): if checka[i] == "$": pi.append(binary[i] ) if len(snake_case_ ) == 0: return pi a = list(set(snake_case_ ) ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> list[str]: """simple docstring""" a = [] for minterm in minterms: a = '''''' for _ in range(snake_case_ ): a = str(minterm % 2 ) + string minterm //= 2 temp.append(snake_case_ ) return temp def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> bool: """simple docstring""" a = list(snake_case_ ) a = list(snake_case_ ) a = 0 for i in range(len(snake_case_ ) ): if lista[i] != lista[i]: count_n += 1 return count_n == count def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> list[str]: """simple docstring""" a = [] a = [0] * len(snake_case_ ) for i in range(len(chart[0] ) ): a = 0 a = -1 for j in range(len(snake_case_ ) ): if chart[j][i] == 1: count += 1 a = j if count == 1: a = 1 for i in range(len(snake_case_ ) ): if select[i] == 1: for j in range(len(chart[0] ) ): if chart[i][j] == 1: for k in range(len(snake_case_ ) ): a = 0 temp.append(prime_implicants[i] ) while True: a = 0 a = -1 a = 0 for i in range(len(snake_case_ ) ): a = chart[i].count(1 ) if count_n > max_n: a = count_n a = i if max_n == 0: return temp temp.append(prime_implicants[rem] ) for i in range(len(chart[0] ) ): if chart[rem][i] == 1: for j in range(len(snake_case_ ) ): a = 0 def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> list[list[int]]: """simple docstring""" a = [[0 for x in range(len(snake_case_ ) )] for x in range(len(snake_case_ ) )] for i in range(len(snake_case_ ) ): a = prime_implicants[i].count('''_''' ) for j in range(len(snake_case_ ) ): if is_for_table(prime_implicants[i], binary[j], snake_case_ ): a = 1 return chart def SCREAMING_SNAKE_CASE__ ( ) -> None: """simple docstring""" a = int(input('''Enter the no. of variables\n''' ) ) a = [ float(snake_case_ ) for x in input( '''Enter the decimal representation of Minterms \'Spaces Separated\'\n''' ).split() ] a = decimal_to_binary(snake_case_, snake_case_ ) a = check(snake_case_ ) print('''Prime Implicants are:''' ) print(snake_case_ ) a = prime_implicant_chart(snake_case_, snake_case_ ) a = selection(snake_case_, snake_case_ ) print('''Essential Prime Implicants are:''' ) print(snake_case_ ) if __name__ == "__main__": import doctest doctest.testmod() main()
330
0
import random def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> List[Any]: """simple docstring""" a = num - 1 a = 0 while s % 2 == 0: a = s // 2 t += 1 for _ in range(5 ): a = random.randrange(2, num - 1 ) a = pow(a__, a__, a__ ) if v != 1: a = 0 while v != (num - 1): if i == t - 1: return False else: a = i + 1 a = (v**2) % num return True def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Optional[int]: """simple docstring""" if num < 2: return False a = [ 2, 3, 5, 7, 1_1, 1_3, 1_7, 1_9, 2_3, 2_9, 3_1, 3_7, 4_1, 4_3, 4_7, 5_3, 5_9, 6_1, 6_7, 7_1, 7_3, 7_9, 8_3, 8_9, 9_7, 1_0_1, 1_0_3, 1_0_7, 1_0_9, 1_1_3, 1_2_7, 1_3_1, 1_3_7, 1_3_9, 1_4_9, 1_5_1, 1_5_7, 1_6_3, 1_6_7, 1_7_3, 1_7_9, 1_8_1, 1_9_1, 1_9_3, 1_9_7, 1_9_9, 2_1_1, 2_2_3, 2_2_7, 2_2_9, 2_3_3, 2_3_9, 2_4_1, 2_5_1, 2_5_7, 2_6_3, 2_6_9, 2_7_1, 2_7_7, 2_8_1, 2_8_3, 2_9_3, 3_0_7, 3_1_1, 3_1_3, 3_1_7, 3_3_1, 3_3_7, 3_4_7, 3_4_9, 3_5_3, 3_5_9, 3_6_7, 3_7_3, 3_7_9, 3_8_3, 3_8_9, 3_9_7, 4_0_1, 4_0_9, 4_1_9, 4_2_1, 4_3_1, 4_3_3, 4_3_9, 4_4_3, 4_4_9, 4_5_7, 4_6_1, 4_6_3, 4_6_7, 4_7_9, 4_8_7, 4_9_1, 4_9_9, 5_0_3, 5_0_9, 5_2_1, 5_2_3, 5_4_1, 5_4_7, 5_5_7, 5_6_3, 5_6_9, 5_7_1, 5_7_7, 5_8_7, 5_9_3, 5_9_9, 6_0_1, 6_0_7, 6_1_3, 6_1_7, 6_1_9, 6_3_1, 6_4_1, 6_4_3, 6_4_7, 6_5_3, 6_5_9, 6_6_1, 6_7_3, 6_7_7, 6_8_3, 6_9_1, 7_0_1, 7_0_9, 7_1_9, 7_2_7, 7_3_3, 7_3_9, 7_4_3, 7_5_1, 7_5_7, 7_6_1, 7_6_9, 7_7_3, 7_8_7, 7_9_7, 8_0_9, 8_1_1, 8_2_1, 8_2_3, 8_2_7, 8_2_9, 8_3_9, 8_5_3, 8_5_7, 8_5_9, 8_6_3, 8_7_7, 8_8_1, 8_8_3, 8_8_7, 9_0_7, 9_1_1, 9_1_9, 9_2_9, 9_3_7, 9_4_1, 9_4_7, 9_5_3, 9_6_7, 9_7_1, 9_7_7, 9_8_3, 9_9_1, 9_9_7, ] if num in low_primes: return True for prime in low_primes: if (num % prime) == 0: return False return rabin_miller(a__ ) def SCREAMING_SNAKE_CASE__ ( snake_case_ = 1_0_2_4 ) -> Optional[int]: """simple docstring""" while True: a = random.randrange(2 ** (keysize - 1), 2 ** (keysize) ) if is_prime_low_num(a__ ): return num if __name__ == "__main__": UpperCamelCase__ : Any = generate_large_prime() print(("""Prime number:""", num)) print(("""is_prime_low_num:""", is_prime_low_num(num)))
369
from typing import List, Union import numpy as np from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_torch_available(): import torch from ..models.auto.modeling_auto import MODEL_FOR_DEPTH_ESTIMATION_MAPPING UpperCamelCase__ : List[str] = logging.get_logger(__name__) @add_end_docstrings(a_ ) class lowerCamelCase_ ( a_ ): def __init__( self : int ,*__lowerCamelCase : str ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' super().__init__(*__lowerCamelCase ,**__lowerCamelCase ) requires_backends(self ,'''vision''' ) self.check_model_type(__lowerCamelCase ) def __call__( self : int ,__lowerCamelCase : Union[str, List[str], "Image.Image", List["Image.Image"]] ,**__lowerCamelCase : str ): '''simple docstring''' return super().__call__(__lowerCamelCase ,**__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Any ,**__lowerCamelCase : Dict ): '''simple docstring''' return {}, {}, {} def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = load_image(__lowerCamelCase ) a = image.size a = self.image_processor(images=__lowerCamelCase ,return_tensors=self.framework ) return model_inputs def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = self.model(**__lowerCamelCase ) return model_outputs def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = model_outputs.predicted_depth a = torch.nn.functional.interpolate( predicted_depth.unsqueeze(1 ) ,size=self.image_size[::-1] ,mode='''bicubic''' ,align_corners=__lowerCamelCase ) a = prediction.squeeze().cpu().numpy() a = (output * 2_55 / np.max(__lowerCamelCase )).astype('''uint8''' ) a = Image.fromarray(__lowerCamelCase ) a = {} a = predicted_depth a = depth return output_dict
330
0
import argparse import fairseq import torch from torch import nn from transformers import ( MBartaaTokenizer, MBartConfig, MBartForCausalLM, SpeechEncoderDecoderConfig, SpeechEncoderDecoderModel, WavaVecaConfig, WavaVecaFeatureExtractor, WavaVecaModel, logging, ) logging.set_verbosity_info() UpperCamelCase__ = logging.get_logger(__name__) UpperCamelCase__ = { """post_extract_proj""": """feature_projection.projection""", """encoder.pos_conv.0""": """encoder.pos_conv_embed.conv""", """self_attn.k_proj""": """encoder.layers.*.attention.k_proj""", """self_attn.v_proj""": """encoder.layers.*.attention.v_proj""", """self_attn.q_proj""": """encoder.layers.*.attention.q_proj""", """self_attn.out_proj""": """encoder.layers.*.attention.out_proj""", """self_attn_layer_norm""": """encoder.layers.*.layer_norm""", """fc1""": """encoder.layers.*.feed_forward.intermediate_dense""", """fc2""": """encoder.layers.*.feed_forward.output_dense""", """final_layer_norm""": """encoder.layers.*.final_layer_norm""", """encoder.layer_norm""": """encoder.layer_norm""", """w2v_model.layer_norm""": """feature_projection.layer_norm""", """quantizer.weight_proj""": """quantizer.weight_proj""", """quantizer.vars""": """quantizer.codevectors""", """project_q""": """project_q""", """final_proj""": """project_hid""", """w2v_encoder.proj""": """lm_head""", """mask_emb""": """masked_spec_embed""", } UpperCamelCase__ = [ """lm_head""", """quantizer.weight_proj""", """quantizer.codevectors""", """project_q""", """project_hid""", ] def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) -> int: """simple docstring""" for attribute in key.split('''.''' ): a = getattr(__SCREAMING_SNAKE_CASE, __SCREAMING_SNAKE_CASE ) if weight_type is not None: a = getattr(__SCREAMING_SNAKE_CASE, __SCREAMING_SNAKE_CASE ).shape else: a = 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": a = value elif weight_type == "weight_g": a = value elif weight_type == "weight_v": a = value elif weight_type == "bias": a = value else: a = value logger.info(f"""{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.""" ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> Optional[Any]: """simple docstring""" a = [] a = fairseq_model.state_dict() a = hf_model.feature_extractor a = hf_model.adapter for name, value in fairseq_dict.items(): a = 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 = True elif any(x in name for x in ['''adaptor''', '''w2v_encoder.proj.''', '''w2v_proj_ln.'''] ): load_adapter(__SCREAMING_SNAKE_CASE, __SCREAMING_SNAKE_CASE, __SCREAMING_SNAKE_CASE, __SCREAMING_SNAKE_CASE ) a = True else: for key, mapped_key in MAPPING.items(): if key in name or key.split('''w2v_model.''' )[-1] == name.split('''.''' )[0]: a = True if "*" in mapped_key: a = name.split(__SCREAMING_SNAKE_CASE )[0].split('''.''' )[-2] a = mapped_key.replace('''*''', __SCREAMING_SNAKE_CASE ) if "weight_g" in name: a = """weight_g""" elif "weight_v" in name: a = """weight_v""" elif "bias" in name: a = """bias""" elif "weight" in name: a = """weight""" else: a = None set_recursively(__SCREAMING_SNAKE_CASE, __SCREAMING_SNAKE_CASE, __SCREAMING_SNAKE_CASE, __SCREAMING_SNAKE_CASE, __SCREAMING_SNAKE_CASE ) continue if not is_used: unused_weights.append(__SCREAMING_SNAKE_CASE ) logger.warning(f"""Unused weights: {unused_weights}""" ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) -> int: """simple docstring""" a = full_name.split('''conv_layers.''' )[-1] a = name.split('''.''' ) a = int(items[0] ) a = 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.""" ) a = 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.""" ) a = 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." ) a = 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.""" ) a = value logger.info(f"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.""" ) else: unused_weights.append(__SCREAMING_SNAKE_CASE ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_ ) -> Any: """simple docstring""" a = full_name.split('''adaptor.''' )[-1] a = name.split('''.''' ) if items[1].isdigit(): a = int(items[1] ) else: a = None if "adaptor" not in full_name: if "proj_ln" in full_name: # has to be layer norm if "bias" in name: assert ( value.shape == adapter.proj_layer_norm.bias.data.shape ), f"""{full_name} has size {value.shape}, but {adapter.proj_layer_norm.bias.data.shape} was found.""" a = value logger.info(f"""Adapter proj layer norm bias was initialized from {full_name}.""" ) if "weight" in name: assert ( value.shape == adapter.proj_layer_norm.weight.data.shape ), f"""{full_name} has size {value.shape}, but {adapter.proj_layer_norm.weight.data.shape} was found.""" a = value else: # has to be projection layer if "bias" in name: assert ( value.shape == adapter.proj.bias.data.shape ), f"""{full_name} has size {value.shape}, but {adapter.proj.bias.data.shape} was found.""" a = value logger.info(f"""Adapter proj layer bias was initialized from {full_name}.""" ) if "weight" in name: assert ( value.shape == adapter.proj.weight.data.shape ), f"""{full_name} has size {value.shape}, but {adapter.proj.weight.data.shape} was found.""" a = value logger.info(f"""Adapter proj layer weight was initialized from {full_name}.""" ) elif isinstance(__SCREAMING_SNAKE_CASE, __SCREAMING_SNAKE_CASE ): if "bias" in name: assert ( value.shape == adapter.layers[layer_id].conv.bias.data.shape ), f"""{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.bias.data.shape} was found.""" a = value logger.info(f"""Adapter layer {layer_id} bias was initialized from {full_name}.""" ) elif "weight" in name: assert ( value.shape == adapter.layers[layer_id].conv.weight.data.shape ), f"""{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.weight.data.shape} was found.""" a = value logger.info(f"""Adapter layer {layer_id} bias was initialized from {full_name}.""" ) else: unused_weights.append(__SCREAMING_SNAKE_CASE ) def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Union[str, Any]: """simple docstring""" a = emb.weight.shape a = nn.Linear(__SCREAMING_SNAKE_CASE, __SCREAMING_SNAKE_CASE, bias=__SCREAMING_SNAKE_CASE ) a = emb.weight.data return lin_layer @torch.no_grad() def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_, snake_case_, snake_case_, snake_case_, snake_case_, snake_case_, snake_case_, ) -> Union[str, Any]: """simple docstring""" a = WavaVecaConfig.from_pretrained( __SCREAMING_SNAKE_CASE, add_adapter=__SCREAMING_SNAKE_CASE, adapter_stride=__SCREAMING_SNAKE_CASE, adapter_kernel_size=__SCREAMING_SNAKE_CASE, use_auth_token=__SCREAMING_SNAKE_CASE, output_hidden_size=__SCREAMING_SNAKE_CASE, ) a = MBartConfig.from_pretrained(__SCREAMING_SNAKE_CASE ) # load model a = fairseq.checkpoint_utils.load_model_ensemble_and_task( [checkpoint_path], arg_overrides={ '''config_yaml''': config_yaml_path, '''data''': '''/'''.join(dict_path.split('''/''' )[:-1] ), '''w2v_path''': checkpoint_path, '''load_pretrained_decoder_from''': None, }, ) a = model[0].eval() # load feature extractor a = WavaVecaFeatureExtractor.from_pretrained(__SCREAMING_SNAKE_CASE, use_auth_token=__SCREAMING_SNAKE_CASE ) # set weights for wav2vec2 encoder a = WavaVecaModel(__SCREAMING_SNAKE_CASE ) recursively_load_weights_wavaveca(model.encoder, __SCREAMING_SNAKE_CASE ) # load decoder weights a = MBartForCausalLM(__SCREAMING_SNAKE_CASE ) a = hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict(), strict=__SCREAMING_SNAKE_CASE ) logger.warning(f"""The following keys are missing when loading the decoder weights: {missing_keys}""" ) logger.warning(f"""The following keys are unexpected when loading the decoder weights: {unexpected_keys}""" ) a = SpeechEncoderDecoderModel(encoder=__SCREAMING_SNAKE_CASE, decoder=__SCREAMING_SNAKE_CASE ) a = False a = MBartaaTokenizer(__SCREAMING_SNAKE_CASE ) tokenizer.save_pretrained(__SCREAMING_SNAKE_CASE ) a = hf_wavavec.config.to_dict() a = tokenizer.pad_token_id a = tokenizer.bos_token_id a = tokenizer.eos_token_id a = """mbart50""" a = """wav2vec2""" a = tokenizer.eos_token_id a = 2_5_0_0_0_4 a = tokenizer.eos_token_id a = SpeechEncoderDecoderConfig.from_dict(__SCREAMING_SNAKE_CASE ) hf_wavavec.save_pretrained(__SCREAMING_SNAKE_CASE ) feature_extractor.save_pretrained(__SCREAMING_SNAKE_CASE ) if __name__ == "__main__": UpperCamelCase__ = argparse.ArgumentParser() parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""") parser.add_argument("""--checkpoint_path""", default=None, type=str, help="""Path to fairseq checkpoint""") parser.add_argument("""--dict_path""", default=None, type=str, help="""Path to dict of fine-tuned model""") parser.add_argument("""--config_yaml_path""", default=None, type=str, help="""Path to yaml file of fine-tuned model""") parser.add_argument( """--encoder_config_path""", default="""facebook/wav2vec2-xls-r-1b""", type=str, help="""Path to hf encoder wav2vec2 checkpoint config""", ) parser.add_argument( """--decoder_config_path""", default="""facebook/mbart-large-50-one-to-many-mmt""", type=str, help="""Path to hf decoder checkpoint config""", ) parser.add_argument("""--add_adapter""", default=True, type=bool, help="""whethere to add model adapter layers""") parser.add_argument("""--adapter_stride""", default=2, type=int, help="""stride of adapter layers""") parser.add_argument("""--adapter_kernel_size""", default=3, type=int, help="""kernel size of adapter layers""") parser.add_argument("""--encoder_output_dim""", default=1_024, type=int, help="""encoder output dim""") parser.add_argument("""--start_token_id""", default=250_004, type=int, help="""`decoder_start_token_id` of model config""") UpperCamelCase__ = parser.parse_args() convert_wavaveca_checkpoint( args.checkpoint_path, args.pytorch_dump_folder_path, args.dict_path, args.config_yaml_path, encoder_config_path=args.encoder_config_path, decoder_config_path=args.decoder_config_path, add_adapter=args.add_adapter, adapter_kernel_size=args.adapter_kernel_size, adapter_stride=args.adapter_stride, decoder_start_token_id=args.start_token_id, encoder_output_dim=args.encoder_output_dim, )
370
from dataclasses import dataclass, field from typing import ClassVar, Dict from ..features import Features, Value from .base import TaskTemplate @dataclass(frozen=a_ ) class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = field(default='language-modeling' , metadata={'include_in_asdict_even_if_is_default': True} ) SCREAMING_SNAKE_CASE_ = Features({'text': Value('string' )} ) SCREAMING_SNAKE_CASE_ = Features({} ) SCREAMING_SNAKE_CASE_ = "text" @property def SCREAMING_SNAKE_CASE_ ( self : int ): '''simple docstring''' return {self.text_column: "text"}
330
0
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available UpperCamelCase__ : List[str] = { "configuration_data2vec_audio": ["DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP", "Data2VecAudioConfig"], "configuration_data2vec_text": [ "DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP", "Data2VecTextConfig", "Data2VecTextOnnxConfig", ], "configuration_data2vec_vision": [ "DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP", "Data2VecVisionConfig", "Data2VecVisionOnnxConfig", ], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCamelCase__ : Any = [ "DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST", "Data2VecAudioForAudioFrameClassification", "Data2VecAudioForCTC", "Data2VecAudioForSequenceClassification", "Data2VecAudioForXVector", "Data2VecAudioModel", "Data2VecAudioPreTrainedModel", ] UpperCamelCase__ : Any = [ "DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST", "Data2VecTextForCausalLM", "Data2VecTextForMaskedLM", "Data2VecTextForMultipleChoice", "Data2VecTextForQuestionAnswering", "Data2VecTextForSequenceClassification", "Data2VecTextForTokenClassification", "Data2VecTextModel", "Data2VecTextPreTrainedModel", ] UpperCamelCase__ : Any = [ "DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST", "Data2VecVisionForImageClassification", "Data2VecVisionForMaskedImageModeling", "Data2VecVisionForSemanticSegmentation", "Data2VecVisionModel", "Data2VecVisionPreTrainedModel", ] if is_tf_available(): UpperCamelCase__ : Dict = [ "TFData2VecVisionForImageClassification", "TFData2VecVisionForSemanticSegmentation", "TFData2VecVisionModel", "TFData2VecVisionPreTrainedModel", ] if TYPE_CHECKING: from .configuration_dataavec_audio import DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP, DataaVecAudioConfig from .configuration_dataavec_text import ( DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, DataaVecTextConfig, DataaVecTextOnnxConfig, ) from .configuration_dataavec_vision import ( DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP, DataaVecVisionConfig, DataaVecVisionOnnxConfig, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_dataavec_audio import ( DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST, DataaVecAudioForAudioFrameClassification, DataaVecAudioForCTC, DataaVecAudioForSequenceClassification, DataaVecAudioForXVector, DataaVecAudioModel, DataaVecAudioPreTrainedModel, ) from .modeling_dataavec_text import ( DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST, DataaVecTextForCausalLM, DataaVecTextForMaskedLM, DataaVecTextForMultipleChoice, DataaVecTextForQuestionAnswering, DataaVecTextForSequenceClassification, DataaVecTextForTokenClassification, DataaVecTextModel, DataaVecTextPreTrainedModel, ) from .modeling_dataavec_vision import ( DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST, DataaVecVisionForImageClassification, DataaVecVisionForMaskedImageModeling, DataaVecVisionForSemanticSegmentation, DataaVecVisionModel, DataaVecVisionPreTrainedModel, ) if is_tf_available(): from .modeling_tf_dataavec_vision import ( TFDataaVecVisionForImageClassification, TFDataaVecVisionForSemanticSegmentation, TFDataaVecVisionModel, TFDataaVecVisionPreTrainedModel, ) else: import sys UpperCamelCase__ : Optional[Any] = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
371
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__ : Union[str, Any] = logging.get_logger(__name__) UpperCamelCase__ : Union[str, Any] = { """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_ ): SCREAMING_SNAKE_CASE_ = 'yolos' def __init__( self : Union[str, Any] ,__lowerCamelCase : int=7_68 ,__lowerCamelCase : Dict=12 ,__lowerCamelCase : Union[str, Any]=12 ,__lowerCamelCase : List[Any]=30_72 ,__lowerCamelCase : int="gelu" ,__lowerCamelCase : int=0.0 ,__lowerCamelCase : str=0.0 ,__lowerCamelCase : Optional[Any]=0.02 ,__lowerCamelCase : int=1e-12 ,__lowerCamelCase : Any=[5_12, 8_64] ,__lowerCamelCase : Tuple=16 ,__lowerCamelCase : int=3 ,__lowerCamelCase : Tuple=True ,__lowerCamelCase : Optional[int]=1_00 ,__lowerCamelCase : List[Any]=True ,__lowerCamelCase : List[str]=False ,__lowerCamelCase : int=1 ,__lowerCamelCase : List[Any]=5 ,__lowerCamelCase : Optional[int]=2 ,__lowerCamelCase : int=5 ,__lowerCamelCase : str=2 ,__lowerCamelCase : Tuple=0.1 ,**__lowerCamelCase : List[Any] ,): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = hidden_size a = num_hidden_layers a = num_attention_heads a = intermediate_size a = hidden_act a = hidden_dropout_prob a = attention_probs_dropout_prob a = initializer_range a = layer_norm_eps a = image_size a = patch_size a = num_channels a = qkv_bias a = num_detection_tokens a = use_mid_position_embeddings a = auxiliary_loss # Hungarian matcher a = class_cost a = bbox_cost a = giou_cost # Loss coefficients a = bbox_loss_coefficient a = giou_loss_coefficient a = eos_coefficient class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = version.parse('1.11' ) @property def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' return OrderedDict( [ ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}), ] ) @property def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ): '''simple docstring''' return 1e-4 @property def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' return 12
330
0
import warnings from ...processing_utils import ProcessorMixin from ...tokenization_utils_base import BatchEncoding class lowerCamelCase_ ( __lowercase ): SCREAMING_SNAKE_CASE_ = ['image_processor', 'tokenizer'] SCREAMING_SNAKE_CASE_ = 'ViTImageProcessor' SCREAMING_SNAKE_CASE_ = ('CLIPTokenizer', 'CLIPTokenizerFast') def __init__( self : int ,__lowerCamelCase : int=None ,__lowerCamelCase : Union[str, Any]=None ,**__lowerCamelCase : List[str] ): '''simple docstring''' a = None if "feature_extractor" in kwargs: warnings.warn( '''The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`''' ''' instead.''' ,_a ,) a = kwargs.pop('''feature_extractor''' ) a = image_processor if image_processor is not None else feature_extractor if image_processor is None: raise ValueError('''You need to specify an `image_processor`.''' ) if tokenizer is None: raise ValueError('''You need to specify a `tokenizer`.''' ) super().__init__(_a ,_a ) def __call__( self : List[Any] ,__lowerCamelCase : Dict=None ,__lowerCamelCase : str=None ,__lowerCamelCase : str=None ,__lowerCamelCase : str=None ,**__lowerCamelCase : Dict ): '''simple docstring''' if text is None and visual_prompt is None and images is None: raise ValueError('''You have to specify either text, visual prompt or images.''' ) if text is not None and visual_prompt is not None: raise ValueError('''You have to specify exactly one type of prompt. Either text or visual prompt.''' ) if text is not None: a = self.tokenizer(_a ,return_tensors=_a ,**_a ) if visual_prompt is not None: a = self.image_processor(_a ,return_tensors=_a ,**_a ) if images is not None: a = self.image_processor(_a ,return_tensors=_a ,**_a ) if visual_prompt is not None and images is not None: a = { '''pixel_values''': image_features.pixel_values, '''conditional_pixel_values''': prompt_features.pixel_values, } return encoding elif text is not None and images is not None: a = image_features.pixel_values return encoding elif text is not None: return encoding elif visual_prompt is not None: a = { '''conditional_pixel_values''': prompt_features.pixel_values, } return encoding else: return BatchEncoding(data=dict(**_a ) ,tensor_type=_a ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ,*__lowerCamelCase : Optional[Any] ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' return self.tokenizer.batch_decode(*_a ,**_a ) def SCREAMING_SNAKE_CASE_ ( self : List[Any] ,*__lowerCamelCase : Optional[Any] ,**__lowerCamelCase : Union[str, Any] ): '''simple docstring''' return self.tokenizer.decode(*_a ,**_a ) @property def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ): '''simple docstring''' warnings.warn( '''`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.''' ,_a ,) return self.image_processor_class @property def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ): '''simple docstring''' warnings.warn( '''`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.''' ,_a ,) return self.image_processor
350
def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> int: """simple docstring""" a = '''''' for i in table: res += inp[i - 1] return res def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> int: """simple docstring""" return data[1:] + data[0] def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> List[str]: """simple docstring""" a = '''''' for i in range(len(snake_case_ ) ): if a[i] == b[i]: res += "0" else: res += "1" return res def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> Dict: """simple docstring""" a = int('''0b''' + data[0] + data[-1], 2 ) a = int('''0b''' + data[1:3], 2 ) return bin(s[row][col] )[2:] def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) -> Optional[int]: """simple docstring""" a = message[:4] a = message[4:] a = apply_table(snake_case_, snake_case_ ) a = xor(snake_case_, snake_case_ ) a = apply_sbox(snake_case_, temp[:4] ) # noqa: E741 a = apply_sbox(snake_case_, temp[4:] ) a = '''0''' * (2 - len(snake_case_ )) + l # noqa: E741 a = '''0''' * (2 - len(snake_case_ )) + r a = apply_table(l + r, snake_case_ ) a = xor(snake_case_, snake_case_ ) return temp + right if __name__ == "__main__": UpperCamelCase__ : int = input("""Enter 10 bit key: """) UpperCamelCase__ : Union[str, Any] = input("""Enter 8 bit message: """) UpperCamelCase__ : Dict = [6, 3, 7, 4, 8, 5, 10, 9] UpperCamelCase__ : Union[str, Any] = [3, 5, 2, 7, 4, 10, 1, 9, 8, 6] UpperCamelCase__ : Optional[int] = [2, 4, 3, 1] UpperCamelCase__ : List[Any] = [2, 6, 3, 1, 4, 8, 5, 7] UpperCamelCase__ : str = [4, 1, 3, 5, 7, 2, 8, 6] UpperCamelCase__ : List[Any] = [4, 1, 2, 3, 2, 3, 4, 1] UpperCamelCase__ : int = [[1, 0, 3, 2], [3, 2, 1, 0], [0, 2, 1, 3], [3, 1, 3, 2]] UpperCamelCase__ : Dict = [[0, 1, 2, 3], [2, 0, 1, 3], [3, 0, 1, 0], [2, 1, 0, 3]] # key generation UpperCamelCase__ : Optional[Any] = apply_table(key, paa_table) UpperCamelCase__ : str = temp[:5] UpperCamelCase__ : List[Any] = temp[5:] UpperCamelCase__ : Dict = left_shift(left) UpperCamelCase__ : Any = left_shift(right) UpperCamelCase__ : Optional[Any] = apply_table(left + right, pa_table) UpperCamelCase__ : List[str] = left_shift(left) UpperCamelCase__ : int = left_shift(right) UpperCamelCase__ : List[str] = left_shift(left) UpperCamelCase__ : Dict = left_shift(right) UpperCamelCase__ : List[str] = apply_table(left + right, pa_table) # encryption UpperCamelCase__ : Tuple = apply_table(message, IP) UpperCamelCase__ : Optional[Any] = function(expansion, sa, sa, keya, temp) UpperCamelCase__ : Optional[int] = temp[4:] + temp[:4] UpperCamelCase__ : Any = function(expansion, sa, sa, keya, temp) UpperCamelCase__ : Tuple = apply_table(temp, IP_inv) print("""Cipher text is:""", CT) # decryption UpperCamelCase__ : Union[str, Any] = apply_table(CT, IP) UpperCamelCase__ : List[str] = function(expansion, sa, sa, keya, temp) UpperCamelCase__ : Optional[Any] = temp[4:] + temp[:4] UpperCamelCase__ : Optional[int] = function(expansion, sa, sa, keya, temp) UpperCamelCase__ : Any = apply_table(temp, IP_inv) print("""Plain text after decypting is:""", PT)
330
0
import random import unittest import torch from diffusers import IFImgaImgSuperResolutionPipeline from diffusers.utils import floats_tensor from diffusers.utils.import_utils import is_xformers_available from diffusers.utils.testing_utils import skip_mps, torch_device from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS from ..test_pipelines_common import PipelineTesterMixin from . import IFPipelineTesterMixin @skip_mps class lowerCamelCase_ ( lowercase__ , lowercase__ , unittest.TestCase ): SCREAMING_SNAKE_CASE_ = IFImgaImgSuperResolutionPipeline SCREAMING_SNAKE_CASE_ = TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""width""", """height"""} SCREAMING_SNAKE_CASE_ = TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'original_image'} ) SCREAMING_SNAKE_CASE_ = PipelineTesterMixin.required_optional_params - {"""latents"""} def SCREAMING_SNAKE_CASE_ ( self : List[str] ): '''simple docstring''' return self._get_superresolution_dummy_components() def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ,__lowerCamelCase : Optional[int] ,__lowerCamelCase : Dict=0 ): '''simple docstring''' if str(lowercase_ ).startswith('''mps''' ): a = torch.manual_seed(lowercase_ ) else: a = torch.Generator(device=lowercase_ ).manual_seed(lowercase_ ) a = floats_tensor((1, 3, 32, 32) ,rng=random.Random(lowercase_ ) ).to(lowercase_ ) a = floats_tensor((1, 3, 16, 16) ,rng=random.Random(lowercase_ ) ).to(lowercase_ ) a = { "prompt": "A painting of a squirrel eating a burger", "image": image, "original_image": original_image, "generator": generator, "num_inference_steps": 2, "output_type": "numpy", } return inputs @unittest.skipIf( torch_device != '''cuda''' or not is_xformers_available() ,reason='''XFormers attention is only available with CUDA and `xformers` installed''' ,) def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3 ) def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' self._test_save_load_optional_components() @unittest.skipIf(torch_device != '''cuda''' ,reason='''float16 requires CUDA''' ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ): '''simple docstring''' super().test_save_load_floataa(expected_max_diff=1e-1 ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ): '''simple docstring''' self._test_attention_slicing_forward_pass(expected_max_diff=1e-2 ) def SCREAMING_SNAKE_CASE_ ( self : List[str] ): '''simple docstring''' self._test_save_load_local() def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' self._test_inference_batch_single_identical( expected_max_diff=1e-2 ,)
351
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 lowerCamelCase_ ( unittest.TestCase ): @slow def SCREAMING_SNAKE_CASE_ ( self : Tuple ): '''simple docstring''' a = FlaxXLMRobertaModel.from_pretrained('''xlm-roberta-base''' ) a = AutoTokenizer.from_pretrained('''xlm-roberta-base''' ) a = '''The dog is cute and lives in the garden house''' a = jnp.array([tokenizer.encode(__lowerCamelCase )] ) a = (1, 12, 7_68) # batch_size, sequence_length, embedding_vector_dim a = jnp.array( [[-0.0_101, 0.1_218, -0.0_803, 0.0_801, 0.1_327, 0.0_776, -0.1_215, 0.2_383, 0.3_338, 0.3_106, 0.0_300, 0.0_252]] ) a = model(__lowerCamelCase )['''last_hidden_state'''] self.assertEqual(output.shape ,__lowerCamelCase ) # compare the actual values for a slice of last dim self.assertTrue(jnp.allclose(output[:, :, -1] ,__lowerCamelCase ,atol=1e-3 ) )
330
0
def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> Any: """simple docstring""" a = 0 while b > 0: if b & 1: res += a a += a b >>= 1 return res def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> Union[str, Any]: """simple docstring""" a = 0 while b > 0: if b & 1: a = ((res % c) + (a % c)) % c a += a b >>= 1 return res
352
import argparse import os # New Code # 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 import find_executable_batch_size ######################################################################## # This is a fully working simple example to use Accelerate, # specifically showcasing how to ensure out-of-memory errors never # interrupt training, and builds off the `nlp_example.py` script. # # 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) # # New additions from the base script can be found quickly by # looking for the # New Code # tags # # 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 # ######################################################################## UpperCamelCase__ : Union[str, Any] = 16 UpperCamelCase__ : Dict = 32 def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ = 1_6 ) -> Tuple: """simple docstring""" a = AutoTokenizer.from_pretrained('''bert-base-cased''' ) a = load_dataset('''glue''', '''mrpc''' ) def tokenize_function(snake_case_ ): # max_length=None => use the model max length (it's actually the default) a = 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(): a = 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 a = tokenized_datasets.rename_column('''label''', '''labels''' ) def collate_fn(snake_case_ ): # On TPU it's best to pad everything to the same length or training will be very slow. a = 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": a = 1_6 elif accelerator.mixed_precision != "no": a = 8 else: a = None return tokenizer.pad( snake_case_, padding='''longest''', max_length=snake_case_, pad_to_multiple_of=snake_case_, return_tensors='''pt''', ) # Instantiate dataloaders. a = DataLoader( tokenized_datasets['''train'''], shuffle=snake_case_, collate_fn=snake_case_, batch_size=snake_case_ ) a = 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 UpperCamelCase__ : int = mocked_dataloaders # noqa: F811 def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> List[Any]: """simple docstring""" if os.environ.get('''TESTING_MOCKED_DATALOADERS''', snake_case_ ) == "1": a = 2 # Initialize accelerator a = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision ) # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs a = config['''lr'''] a = int(config['''num_epochs'''] ) a = int(config['''seed'''] ) a = int(config['''batch_size'''] ) a = evaluate.load('''glue''', '''mrpc''' ) # New Code # # We now can define an inner training loop function. It should take a batch size as the only parameter, # and build the dataloaders in there. # It also gets our decorator @find_executable_batch_size(starting_batch_size=snake_case_ ) def inner_training_loop(snake_case_ ): # And now just move everything below under this function # We need to bring in the Accelerator object from earlier nonlocal accelerator # And reset all of its attributes that could hold onto any memory: accelerator.free_memory() # Then we can declare the model, optimizer, and everything else: set_seed(snake_case_ ) # Instantiate the model (we build the model here so that the seed also control new weights initialization) a = 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). a = model.to(accelerator.device ) # Instantiate optimizer a = AdamW(params=model.parameters(), lr=snake_case_ ) a , a = get_dataloaders(snake_case_, snake_case_ ) # Instantiate scheduler a = 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. a , a , a , a , a = 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() 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 ) a = model(**snake_case_ ) a = outputs.loss accelerator.backward(snake_case_ ) optimizer.step() lr_scheduler.step() optimizer.zero_grad() 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(): a = model(**snake_case_ ) a = outputs.logits.argmax(dim=-1 ) a , a = accelerator.gather_for_metrics((predictions, batch['''labels''']) ) metric.add_batch( predictions=snake_case_, references=snake_case_, ) a = metric.compute() # Use accelerator.print to print only on the main process. accelerator.print(f"""epoch {epoch}:""", snake_case_ ) # New Code # # And call it at the end with no arguments # Note: You could also refactor this outside of your training loop function inner_training_loop() def SCREAMING_SNAKE_CASE__ ( ) -> Tuple: """simple docstring""" a = 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.''', ) parser.add_argument('''--cpu''', action='''store_true''', help='''If passed, will train on the CPU.''' ) a = parser.parse_args() a = {'''lr''': 2e-5, '''num_epochs''': 3, '''seed''': 4_2, '''batch_size''': 1_6} training_function(snake_case_, snake_case_ ) if __name__ == "__main__": main()
330
0
from typing import Any, Dict, Optional import torch import torch.nn.functional as F from torch import nn from ..utils import maybe_allow_in_graph from .activations import get_activation from .attention_processor import Attention from .embeddings import CombinedTimestepLabelEmbeddings @maybe_allow_in_graph class lowerCamelCase_ ( nn.Module ): def __init__( self : List[str] ,__lowerCamelCase : List[Any] ,__lowerCamelCase : Any ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : Any=0.0 ,__lowerCamelCase : Any = None ,__lowerCamelCase : Union[str, Any] = "geglu" ,__lowerCamelCase : int = None ,__lowerCamelCase : Union[str, Any] = False ,__lowerCamelCase : List[str] = False ,__lowerCamelCase : Tuple = False ,__lowerCamelCase : Optional[int] = False ,__lowerCamelCase : Tuple = True ,__lowerCamelCase : Optional[int] = "layer_norm" ,__lowerCamelCase : List[str] = False ,): '''simple docstring''' super().__init__() a = only_cross_attention a = (num_embeds_ada_norm is not None) and norm_type == 'ada_norm_zero' a = (num_embeds_ada_norm is not None) and norm_type == 'ada_norm' if norm_type in ("ada_norm", "ada_norm_zero") and num_embeds_ada_norm is None: raise ValueError( F"""`norm_type` is set to {norm_type}, but `num_embeds_ada_norm` is not defined. Please make sure to""" F""" define `num_embeds_ada_norm` if setting `norm_type` to {norm_type}.""" ) # Define 3 blocks. Each block has its own normalization layer. # 1. Self-Attn if self.use_ada_layer_norm: a = AdaLayerNorm(snake_case__ ,snake_case__ ) elif self.use_ada_layer_norm_zero: a = AdaLayerNormZero(snake_case__ ,snake_case__ ) else: a = nn.LayerNorm(snake_case__ ,elementwise_affine=snake_case__ ) a = Attention( query_dim=snake_case__ ,heads=snake_case__ ,dim_head=snake_case__ ,dropout=snake_case__ ,bias=snake_case__ ,cross_attention_dim=cross_attention_dim if only_cross_attention else None ,upcast_attention=snake_case__ ,) # 2. Cross-Attn if cross_attention_dim is not None or double_self_attention: # We currently only use AdaLayerNormZero for self attention where there will only be one attention block. # I.e. the number of returned modulation chunks from AdaLayerZero would not make sense if returned during # the second cross attention block. a = ( AdaLayerNorm(snake_case__ ,snake_case__ ) if self.use_ada_layer_norm else nn.LayerNorm(snake_case__ ,elementwise_affine=snake_case__ ) ) a = Attention( query_dim=snake_case__ ,cross_attention_dim=cross_attention_dim if not double_self_attention else None ,heads=snake_case__ ,dim_head=snake_case__ ,dropout=snake_case__ ,bias=snake_case__ ,upcast_attention=snake_case__ ,) # is self-attn if encoder_hidden_states is none else: a = None a = None # 3. Feed-forward a = nn.LayerNorm(snake_case__ ,elementwise_affine=snake_case__ ) a = FeedForward(snake_case__ ,dropout=snake_case__ ,activation_fn=snake_case__ ,final_dropout=snake_case__ ) # let chunk size default to None a = None a = 0 def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : Union[str, Any] ,__lowerCamelCase : List[str] ): '''simple docstring''' a = chunk_size a = dim def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : List[Any] ,__lowerCamelCase : int = None ,__lowerCamelCase : int = None ,__lowerCamelCase : int = None ,__lowerCamelCase : List[Any] = None ,__lowerCamelCase : Optional[Any] = None ,__lowerCamelCase : Optional[int] = None ,): '''simple docstring''' if self.use_ada_layer_norm: a = self.norma(snake_case__ ,snake_case__ ) elif self.use_ada_layer_norm_zero: a = self.norma( snake_case__ ,snake_case__ ,snake_case__ ,hidden_dtype=hidden_states.dtype ) else: a = self.norma(snake_case__ ) a = cross_attention_kwargs if cross_attention_kwargs is not None else {} a = self.attna( snake_case__ ,encoder_hidden_states=encoder_hidden_states if self.only_cross_attention else None ,attention_mask=snake_case__ ,**snake_case__ ,) if self.use_ada_layer_norm_zero: a = gate_msa.unsqueeze(1 ) * attn_output a = attn_output + hidden_states # 2. Cross-Attention if self.attna is not None: a = ( self.norma(snake_case__ ,snake_case__ ) if self.use_ada_layer_norm else self.norma(snake_case__ ) ) a = self.attna( snake_case__ ,encoder_hidden_states=snake_case__ ,attention_mask=snake_case__ ,**snake_case__ ,) a = attn_output + hidden_states # 3. Feed-forward a = self.norma(snake_case__ ) if self.use_ada_layer_norm_zero: a = norm_hidden_states * (1 + scale_mlp[:, None]) + shift_mlp[:, None] if self._chunk_size is not None: # "feed_forward_chunk_size" can be used to save memory if norm_hidden_states.shape[self._chunk_dim] % self._chunk_size != 0: raise ValueError( F"""`hidden_states` dimension to be chunked: {norm_hidden_states.shape[self._chunk_dim]} has to be divisible by chunk size: {self._chunk_size}. Make sure to set an appropriate `chunk_size` when calling `unet.enable_forward_chunking`.""" ) a = norm_hidden_states.shape[self._chunk_dim] // self._chunk_size a = torch.cat( [self.ff(snake_case__ ) for hid_slice in norm_hidden_states.chunk(snake_case__ ,dim=self._chunk_dim )] ,dim=self._chunk_dim ,) else: a = self.ff(snake_case__ ) if self.use_ada_layer_norm_zero: a = gate_mlp.unsqueeze(1 ) * ff_output a = ff_output + hidden_states return hidden_states class lowerCamelCase_ ( nn.Module ): def __init__( self : Optional[int] ,__lowerCamelCase : int ,__lowerCamelCase : Dict = None ,__lowerCamelCase : Any = 4 ,__lowerCamelCase : List[str] = 0.0 ,__lowerCamelCase : int = "geglu" ,__lowerCamelCase : List[str] = False ,): '''simple docstring''' super().__init__() a = int(dim * mult ) a = dim_out if dim_out is not None else dim if activation_fn == "gelu": a = GELU(snake_case__ ,snake_case__ ) if activation_fn == "gelu-approximate": a = GELU(snake_case__ ,snake_case__ ,approximate='''tanh''' ) elif activation_fn == "geglu": a = GEGLU(snake_case__ ,snake_case__ ) elif activation_fn == "geglu-approximate": a = ApproximateGELU(snake_case__ ,snake_case__ ) a = nn.ModuleList([] ) # project in self.net.append(snake_case__ ) # project dropout self.net.append(nn.Dropout(snake_case__ ) ) # project out self.net.append(nn.Linear(snake_case__ ,snake_case__ ) ) # FF as used in Vision Transformer, MLP-Mixer, etc. have a final dropout if final_dropout: self.net.append(nn.Dropout(snake_case__ ) ) def SCREAMING_SNAKE_CASE_ ( self : Dict ,__lowerCamelCase : List[str] ): '''simple docstring''' for module in self.net: a = module(snake_case__ ) return hidden_states class lowerCamelCase_ ( nn.Module ): def __init__( self : Optional[Any] ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : int = "none" ): '''simple docstring''' super().__init__() a = nn.Linear(snake_case__ ,snake_case__ ) a = approximate def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : int ): '''simple docstring''' if gate.device.type != "mps": return F.gelu(snake_case__ ,approximate=self.approximate ) # mps: gelu is not implemented for float16 return F.gelu(gate.to(dtype=torch.floataa ) ,approximate=self.approximate ).to(dtype=gate.dtype ) def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : Optional[int] ): '''simple docstring''' a = self.proj(snake_case__ ) a = self.gelu(snake_case__ ) return hidden_states class lowerCamelCase_ ( nn.Module ): def __init__( self : str ,__lowerCamelCase : Dict ,__lowerCamelCase : Dict ): '''simple docstring''' super().__init__() a = nn.Linear(snake_case__ ,dim_out * 2 ) def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : Optional[int] ): '''simple docstring''' if gate.device.type != "mps": return F.gelu(snake_case__ ) # mps: gelu is not implemented for float16 return F.gelu(gate.to(dtype=torch.floataa ) ).to(dtype=gate.dtype ) def SCREAMING_SNAKE_CASE_ ( self : Dict ,__lowerCamelCase : Optional[int] ): '''simple docstring''' a = self.proj(snake_case__ ).chunk(2 ,dim=-1 ) return hidden_states * self.gelu(snake_case__ ) class lowerCamelCase_ ( nn.Module ): def __init__( self : Optional[int] ,__lowerCamelCase : Any ,__lowerCamelCase : List[str] ): '''simple docstring''' super().__init__() a = nn.Linear(snake_case__ ,snake_case__ ) def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : List[str] ): '''simple docstring''' a = self.proj(snake_case__ ) return x * torch.sigmoid(1.702 * x ) class lowerCamelCase_ ( nn.Module ): def __init__( self : Dict ,__lowerCamelCase : Any ,__lowerCamelCase : Any ): '''simple docstring''' super().__init__() a = nn.Embedding(snake_case__ ,snake_case__ ) a = nn.SiLU() a = nn.Linear(snake_case__ ,embedding_dim * 2 ) a = nn.LayerNorm(snake_case__ ,elementwise_affine=snake_case__ ) def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : List[Any] ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = self.linear(self.silu(self.emb(snake_case__ ) ) ) a = torch.chunk(snake_case__ ,2 ) a = self.norm(snake_case__ ) * (1 + scale) + shift return x class lowerCamelCase_ ( nn.Module ): def __init__( self : Optional[Any] ,__lowerCamelCase : Any ,__lowerCamelCase : Dict ): '''simple docstring''' super().__init__() a = CombinedTimestepLabelEmbeddings(snake_case__ ,snake_case__ ) a = nn.SiLU() a = nn.Linear(snake_case__ ,6 * embedding_dim ,bias=snake_case__ ) a = nn.LayerNorm(snake_case__ ,elementwise_affine=snake_case__ ,eps=1e-6 ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : Tuple ,__lowerCamelCase : Union[str, Any] ,__lowerCamelCase : Tuple ,__lowerCamelCase : Dict=None ): '''simple docstring''' a = self.linear(self.silu(self.emb(snake_case__ ,snake_case__ ,hidden_dtype=snake_case__ ) ) ) a = emb.chunk(6 ,dim=1 ) a = self.norm(snake_case__ ) * (1 + scale_msa[:, None]) + shift_msa[:, None] return x, gate_msa, shift_mlp, scale_mlp, gate_mlp class lowerCamelCase_ ( nn.Module ): def __init__( self : int ,__lowerCamelCase : Optional[int] ,__lowerCamelCase : Any ,__lowerCamelCase : Dict ,__lowerCamelCase : Tuple = None ,__lowerCamelCase : Union[str, Any] = 1e-5 ): '''simple docstring''' super().__init__() a = num_groups a = eps if act_fn is None: a = None else: a = get_activation(snake_case__ ) a = nn.Linear(snake_case__ ,out_dim * 2 ) def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : List[Any] ): '''simple docstring''' if self.act: a = self.act(snake_case__ ) a = self.linear(snake_case__ ) a = emb[:, :, None, None] a = emb.chunk(2 ,dim=1 ) a = F.group_norm(snake_case__ ,self.num_groups ,eps=self.eps ) a = x * (1 + scale) + shift return x
353
import argparse import fairseq import torch from transformers import UniSpeechSatConfig, UniSpeechSatForCTC, UniSpeechSatForPreTraining, logging logging.set_verbosity_info() UpperCamelCase__ : Optional[int] = logging.get_logger(__name__) UpperCamelCase__ : str = { """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""", """encoder.layer_norm_for_extract""": """layer_norm_for_extract""", """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""", """label_embs_concat""": """label_embeddings_concat""", """mask_emb""": """masked_spec_embed""", """spk_proj""": """speaker_proj""", } UpperCamelCase__ : Optional[Any] = [ """lm_head""", """quantizer.weight_proj""", """quantizer.codevectors""", """project_q""", """project_hid""", """label_embeddings_concat""", """speaker_proj""", """layer_norm_for_extract""", ] def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) -> List[Any]: """simple docstring""" for attribute in key.split('''.''' ): a = getattr(snake_case_, snake_case_ ) if weight_type is not None: a = getattr(snake_case_, snake_case_ ).shape else: a = 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 = value elif weight_type == "weight_g": a = value elif weight_type == "weight_v": a = value elif weight_type == "bias": a = value else: a = value logger.info(f"""{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.""" ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> Union[str, Any]: """simple docstring""" a = [] a = fairseq_model.state_dict() a = hf_model.unispeech_sat.feature_extractor for name, value in fairseq_dict.items(): a = False if "conv_layers" in name: load_conv_layer( snake_case_, snake_case_, snake_case_, snake_case_, hf_model.config.feat_extract_norm == '''group''', ) a = True else: for key, mapped_key in MAPPING.items(): a = '''unispeech_sat.''' + 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]: if "layer_norm_for_extract" in name and (".".join(name.split('''.''' )[:-1] ) != key): # special case since naming is very similar continue a = True if "*" in mapped_key: a = name.split(snake_case_ )[0].split('''.''' )[-2] a = mapped_key.replace('''*''', snake_case_ ) if "weight_g" in name: a = '''weight_g''' elif "weight_v" in name: a = '''weight_v''' elif "bias" in name: a = '''bias''' elif "weight" in name: # TODO: don't match quantizer.weight_proj a = '''weight''' else: a = None set_recursively(snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) continue if not is_used: unused_weights.append(snake_case_ ) logger.warning(f"""Unused weights: {unused_weights}""" ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) -> Union[str, Any]: """simple docstring""" a = full_name.split('''conv_layers.''' )[-1] a = name.split('''.''' ) a = int(items[0] ) a = 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 = 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 = 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[layer_id].layer_norm.bias.data.shape} was found.""" ) a = 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[layer_id].layer_norm.weight.data.shape} was found.""" ) a = value logger.info(f"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.""" ) else: unused_weights.append(snake_case_ ) @torch.no_grad() def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_=None, snake_case_=None, snake_case_=True ) -> Union[str, Any]: """simple docstring""" if config_path is not None: a = UniSpeechSatConfig.from_pretrained(snake_case_ ) else: a = UniSpeechSatConfig() a = '''''' if is_finetuned: a = UniSpeechSatForCTC(snake_case_ ) else: a = UniSpeechSatForPreTraining(snake_case_ ) a , a , a = fairseq.checkpoint_utils.load_model_ensemble_and_task( [checkpoint_path], arg_overrides={'''data''': '''/'''.join(dict_path.split('''/''' )[:-1] )} ) a = model[0].eval() recursively_load_weights(snake_case_, snake_case_ ) hf_wavavec.save_pretrained(snake_case_ ) if __name__ == "__main__": UpperCamelCase__ : Optional[int] = argparse.ArgumentParser() parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""") parser.add_argument("""--checkpoint_path""", default=None, type=str, help="""Path to fairseq checkpoint""") parser.add_argument("""--dict_path""", default=None, type=str, help="""Path to dict of fine-tuned model""") parser.add_argument("""--config_path""", default=None, type=str, help="""Path to hf config.json of model to convert""") parser.add_argument( """--not_finetuned""", action="""store_true""", help="""Whether the model to convert is a fine-tuned model or not""" ) UpperCamelCase__ : int = parser.parse_args() convert_unispeech_sat_checkpoint( args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned )
330
0
# # This a `torch.distributed` diagnostics script that checks that all GPUs in the cluster (one or # many nodes) can talk to each other via nccl and allocate gpu memory. # # To run first adjust the number of processes and nodes: # # python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py # # You may need to add --master_addr $MASTER_ADDR --master_port $MASTER_PORT if using a custom addr:port # # You can also use the rdzv API: --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT --rdzv_backend c10d # # use torch.distributed.launch instead of torch.distributed.run for torch < 1.9 # # If you get a hanging in `barrier` calls you have some network issues, you may try to debug this with: # # NCCL_DEBUG=INFO python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py # # which should tell you what's going on behind the scenes. # # # This script can be run via `srun` in the SLURM environment as well. Here is a SLURM script that # runs on 2 nodes of 4 gpus per node: # # #SBATCH --job-name=test-nodes # name # #SBATCH --nodes=2 # nodes # #SBATCH --ntasks-per-node=1 # crucial - only 1 task per dist per node! # #SBATCH --cpus-per-task=10 # number of cores per tasks # #SBATCH --gres=gpu:4 # number of gpus # #SBATCH --time 0:05:00 # maximum execution time (HH:MM:SS) # #SBATCH --output=%x-%j.out # output file name # # GPUS_PER_NODE=4 # MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1) # MASTER_PORT=6000 # # srun --jobid $SLURM_JOBID bash -c 'python -m torch.distributed.run \ # --nproc_per_node $GPUS_PER_NODE --nnodes $SLURM_NNODES --node_rank $SLURM_PROCID \ # --master_addr $MASTER_ADDR --master_port $MASTER_PORT \ # torch-distributed-gpu-test.py' # import fcntl import os import socket import torch import torch.distributed as dist def SCREAMING_SNAKE_CASE__ ( *snake_case_ ) -> List[Any]: """simple docstring""" with open(snake_case_, '''r''' ) as fh: fcntl.flock(snake_case_, fcntl.LOCK_EX ) try: print(*snake_case_ ) finally: fcntl.flock(snake_case_, fcntl.LOCK_UN ) UpperCamelCase__ : Any = int(os.environ["""LOCAL_RANK"""]) torch.cuda.set_device(local_rank) UpperCamelCase__ : str = torch.device("""cuda""", local_rank) UpperCamelCase__ : Tuple = socket.gethostname() UpperCamelCase__ : List[Any] = F"[{hostname}-{local_rank}]" try: # test distributed dist.init_process_group("""nccl""") dist.all_reduce(torch.ones(1).to(device), op=dist.ReduceOp.SUM) dist.barrier() # test cuda is available and can allocate memory torch.cuda.is_available() torch.ones(1).cuda(local_rank) # global rank UpperCamelCase__ : Optional[int] = dist.get_rank() UpperCamelCase__ : List[Any] = dist.get_world_size() printflock(F"{gpu} is OK (global rank: {rank}/{world_size})") dist.barrier() if rank == 0: printflock(F"pt={torch.__version__}, cuda={torch.version.cuda}, nccl={torch.cuda.nccl.version()}") except Exception: printflock(F"{gpu} is broken") raise
354
import pytest from datasets import inspect_metric, list_metrics, load_metric @pytest.fixture def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> List[str]: """simple docstring""" monkeypatch.setattr('''datasets.utils.deprecation_utils._emitted_deprecation_warnings''', set() ) @pytest.fixture def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Optional[int]: """simple docstring""" class lowerCamelCase_ : def __init__( self : Dict ,__lowerCamelCase : List[str] ): '''simple docstring''' a = metric_id class lowerCamelCase_ : SCREAMING_SNAKE_CASE_ = [MetricMock(a_ ) for metric_id in ['accuracy', 'mse', 'precision', 'codeparrot/apps_metric']] def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' return self._metrics monkeypatch.setattr('''datasets.inspect.huggingface_hub''', HfhMock() ) @pytest.mark.parametrize( '''func, args''', [(load_metric, ('''metrics/mse''',)), (list_metrics, ()), (inspect_metric, ('''metrics/mse''', '''tmp_path'''))] ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) -> Tuple: """simple docstring""" if "tmp_path" in args: a = tuple(arg if arg != '''tmp_path''' else tmp_path for arg in args ) with pytest.warns(snake_case_, match='''https://huggingface.co/docs/evaluate''' ): func(*snake_case_ )
330
0
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available UpperCamelCase__ : Dict = { '''configuration_pix2struct''': [ '''PIX2STRUCT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''Pix2StructConfig''', '''Pix2StructTextConfig''', '''Pix2StructVisionConfig''', ], '''processing_pix2struct''': ['''Pix2StructProcessor'''], } try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCamelCase__ : int = ['''Pix2StructImageProcessor'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCamelCase__ : Any = [ '''PIX2STRUCT_PRETRAINED_MODEL_ARCHIVE_LIST''', '''Pix2StructPreTrainedModel''', '''Pix2StructForConditionalGeneration''', '''Pix2StructVisionModel''', '''Pix2StructTextModel''', ] if TYPE_CHECKING: from .configuration_pixastruct import ( PIX2STRUCT_PRETRAINED_CONFIG_ARCHIVE_MAP, PixaStructConfig, PixaStructTextConfig, PixaStructVisionConfig, ) from .processing_pixastruct import PixaStructProcessor try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .image_processing_pixastruct import PixaStructImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_pixastruct import ( PIX2STRUCT_PRETRAINED_MODEL_ARCHIVE_LIST, PixaStructForConditionalGeneration, PixaStructPreTrainedModel, PixaStructTextModel, PixaStructVisionModel, ) else: import sys UpperCamelCase__ : str = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
355
from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCamelCase__ : str = logging.get_logger(__name__) UpperCamelCase__ : Optional[int] = { """studio-ousia/luke-base""": """https://huggingface.co/studio-ousia/luke-base/resolve/main/config.json""", """studio-ousia/luke-large""": """https://huggingface.co/studio-ousia/luke-large/resolve/main/config.json""", } class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = 'luke' def __init__( self : Dict ,__lowerCamelCase : Optional[Any]=5_02_67 ,__lowerCamelCase : str=50_00_00 ,__lowerCamelCase : Any=7_68 ,__lowerCamelCase : int=2_56 ,__lowerCamelCase : Optional[int]=12 ,__lowerCamelCase : Tuple=12 ,__lowerCamelCase : Any=30_72 ,__lowerCamelCase : Any="gelu" ,__lowerCamelCase : Any=0.1 ,__lowerCamelCase : Tuple=0.1 ,__lowerCamelCase : Tuple=5_12 ,__lowerCamelCase : int=2 ,__lowerCamelCase : Optional[int]=0.02 ,__lowerCamelCase : List[Any]=1e-12 ,__lowerCamelCase : Dict=True ,__lowerCamelCase : Tuple=None ,__lowerCamelCase : Any=1 ,__lowerCamelCase : Dict=0 ,__lowerCamelCase : Any=2 ,**__lowerCamelCase : str ,): '''simple docstring''' super().__init__(pad_token_id=__lowerCamelCase ,bos_token_id=__lowerCamelCase ,eos_token_id=__lowerCamelCase ,**__lowerCamelCase ) a = vocab_size a = entity_vocab_size a = hidden_size a = entity_emb_size a = num_hidden_layers a = num_attention_heads a = hidden_act a = intermediate_size a = hidden_dropout_prob a = attention_probs_dropout_prob a = max_position_embeddings a = type_vocab_size a = initializer_range a = layer_norm_eps a = use_entity_aware_attention a = classifier_dropout
330
0
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available UpperCamelCase__ : Dict = {"""configuration_ibert""": ["""IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """IBertConfig""", """IBertOnnxConfig"""]} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCamelCase__ : int = [ """IBERT_PRETRAINED_MODEL_ARCHIVE_LIST""", """IBertForMaskedLM""", """IBertForMultipleChoice""", """IBertForQuestionAnswering""", """IBertForSequenceClassification""", """IBertForTokenClassification""", """IBertModel""", """IBertPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_ibert import IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, IBertConfig, IBertOnnxConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_ibert import ( IBERT_PRETRAINED_MODEL_ARCHIVE_LIST, IBertForMaskedLM, IBertForMultipleChoice, IBertForQuestionAnswering, IBertForSequenceClassification, IBertForTokenClassification, IBertModel, IBertPreTrainedModel, ) else: import sys UpperCamelCase__ : Optional[Any] = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
356
import numpy as np import pandas as pd from sklearn.preprocessing import MinMaxScaler from tensorflow.keras.layers import LSTM, Dense from tensorflow.keras.models import Sequential if __name__ == "__main__": UpperCamelCase__ : Optional[int] = pd.read_csv("""sample_data.csv""", header=None) UpperCamelCase__ : Tuple = df.shape[:1][0] # If you're using some other dataset input the target column UpperCamelCase__ : List[Any] = df.iloc[:, 1:2] UpperCamelCase__ : Union[str, Any] = actual_data.values.reshape(len_data, 1) UpperCamelCase__ : List[Any] = MinMaxScaler().fit_transform(actual_data) UpperCamelCase__ : Optional[Any] = 10 UpperCamelCase__ : int = 5 UpperCamelCase__ : List[str] = 20 UpperCamelCase__ : Optional[int] = len_data - periods * look_back UpperCamelCase__ : Union[str, Any] = actual_data[:division] UpperCamelCase__ : str = actual_data[division - look_back :] UpperCamelCase__ , UpperCamelCase__ : Union[str, Any] = [], [] UpperCamelCase__ , UpperCamelCase__ : str = [], [] for i in range(0, len(train_data) - forward_days - look_back + 1): train_x.append(train_data[i : i + look_back]) train_y.append(train_data[i + look_back : i + look_back + forward_days]) for i in range(0, len(test_data) - forward_days - look_back + 1): test_x.append(test_data[i : i + look_back]) test_y.append(test_data[i + look_back : i + look_back + forward_days]) UpperCamelCase__ : List[str] = np.array(train_x) UpperCamelCase__ : Optional[Any] = np.array(test_x) UpperCamelCase__ : Tuple = np.array([list(i.ravel()) for i in train_y]) UpperCamelCase__ : Optional[Any] = np.array([list(i.ravel()) for i in test_y]) UpperCamelCase__ : Union[str, Any] = Sequential() model.add(LSTM(128, input_shape=(look_back, 1), return_sequences=True)) model.add(LSTM(64, input_shape=(128, 1))) model.add(Dense(forward_days)) model.compile(loss="""mean_squared_error""", optimizer="""adam""") UpperCamelCase__ : Tuple = model.fit( x_train, y_train, epochs=150, verbose=1, shuffle=True, batch_size=4 ) UpperCamelCase__ : Tuple = model.predict(x_test)
330
0
from itertools import count def SCREAMING_SNAKE_CASE__ ( snake_case_ = 5_0 ) -> Dict: """simple docstring""" a = [1] * min_block_length for n in count(A__ ): fill_count_functions.append(1 ) for block_length in range(A__, n + 1 ): for block_start in range(n - block_length ): fill_count_functions[n] += fill_count_functions[ n - block_start - block_length - 1 ] fill_count_functions[n] += 1 if fill_count_functions[n] > 1_0_0_0_0_0_0: break return n if __name__ == "__main__": print(F"{solution() = }")
357
import os import time import pytest from datasets.utils.filelock import FileLock, Timeout def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Tuple: """simple docstring""" a = FileLock(str(tmpdir / '''foo.lock''' ) ) a = FileLock(str(tmpdir / '''foo.lock''' ) ) a = 0.01 with locka.acquire(): with pytest.raises(snake_case_ ): a = time.time() locka.acquire(snake_case_ ) assert time.time() - _start > timeout def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Optional[int]: """simple docstring""" a = '''a''' * 1_0_0_0 + '''.lock''' a = FileLock(str(tmpdir / filename ) ) assert locka._lock_file.endswith('''.lock''' ) assert not locka._lock_file.endswith(snake_case_ ) assert len(os.path.basename(locka._lock_file ) ) <= 2_5_5 a = FileLock(tmpdir / filename ) with locka.acquire(): with pytest.raises(snake_case_ ): locka.acquire(0 )
330
0
from __future__ import annotations class lowerCamelCase_ : """simple docstring""" def __init__( self : List[str] ,__lowerCamelCase : int ): '''simple docstring''' a = data a = None a = None def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Optional[Any]: # In Order traversal of the tree """simple docstring""" if tree: display(tree.left ) print(tree.data ) display(tree.right ) def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> str: """simple docstring""" return 1 + max(depth_of_tree(tree.left ), depth_of_tree(tree.right ) ) if tree else 0 def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Tuple: """simple docstring""" if not tree: return True if tree.left and tree.right: return is_full_binary_tree(tree.left ) and is_full_binary_tree(tree.right ) else: return not tree.left and not tree.right def SCREAMING_SNAKE_CASE__ ( ) -> Dict: # Main function for testing. """simple docstring""" a = Node(1 ) a = Node(2 ) a = Node(3 ) a = Node(4 ) a = Node(5 ) a = Node(6 ) a = Node(7 ) a = Node(8 ) a = Node(9 ) print(is_full_binary_tree(snake_case_ ) ) print(depth_of_tree(snake_case_ ) ) print('''Tree is: ''' ) display(snake_case_ ) if __name__ == "__main__": main()
358
from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCamelCase__ : Optional[int] = logging.get_logger(__name__) UpperCamelCase__ : Dict = { """facebook/vit-mae-base""": """https://huggingface.co/facebook/vit-mae-base/resolve/main/config.json""", # See all ViT MAE models at https://huggingface.co/models?filter=vit-mae } class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = 'vit_mae' def __init__( self : Dict ,__lowerCamelCase : Any=7_68 ,__lowerCamelCase : Optional[Any]=12 ,__lowerCamelCase : List[str]=12 ,__lowerCamelCase : Optional[int]=30_72 ,__lowerCamelCase : int="gelu" ,__lowerCamelCase : Union[str, Any]=0.0 ,__lowerCamelCase : Optional[int]=0.0 ,__lowerCamelCase : Dict=0.02 ,__lowerCamelCase : List[Any]=1e-12 ,__lowerCamelCase : Dict=2_24 ,__lowerCamelCase : str=16 ,__lowerCamelCase : Union[str, Any]=3 ,__lowerCamelCase : Optional[Any]=True ,__lowerCamelCase : Dict=16 ,__lowerCamelCase : List[str]=5_12 ,__lowerCamelCase : int=8 ,__lowerCamelCase : int=20_48 ,__lowerCamelCase : Optional[Any]=0.75 ,__lowerCamelCase : int=False ,**__lowerCamelCase : Any ,): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = hidden_size a = num_hidden_layers a = num_attention_heads a = intermediate_size a = hidden_act a = hidden_dropout_prob a = attention_probs_dropout_prob a = initializer_range a = layer_norm_eps a = image_size a = patch_size a = num_channels a = qkv_bias a = decoder_num_attention_heads a = decoder_hidden_size a = decoder_num_hidden_layers a = decoder_intermediate_size a = mask_ratio a = norm_pix_loss
330
0
from math import pi, sqrt, tan def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> float: """simple docstring""" if side_length < 0: raise ValueError('''surface_area_cube() only accepts non-negative values''' ) return 6 * side_length**2 def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> float: """simple docstring""" if length < 0 or breadth < 0 or height < 0: raise ValueError('''surface_area_cuboid() only accepts non-negative values''' ) return 2 * ((length * breadth) + (breadth * height) + (length * height)) def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> float: """simple docstring""" if radius < 0: raise ValueError('''surface_area_sphere() only accepts non-negative values''' ) return 4 * pi * radius**2 def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> float: """simple docstring""" if radius < 0: raise ValueError('''surface_area_hemisphere() only accepts non-negative values''' ) return 3 * pi * radius**2 def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> float: """simple docstring""" if radius < 0 or height < 0: raise ValueError('''surface_area_cone() only accepts non-negative values''' ) return pi * radius * (radius + (height**2 + radius**2) ** 0.5) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> float: """simple docstring""" if radius_a < 0 or radius_a < 0 or height < 0: raise ValueError( '''surface_area_conical_frustum() only accepts non-negative values''' ) a = (height**2 + (radius_a - radius_a) ** 2) ** 0.5 return pi * ((slant_height * (radius_a + radius_a)) + radius_a**2 + radius_a**2) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> float: """simple docstring""" if radius < 0 or height < 0: raise ValueError('''surface_area_cylinder() only accepts non-negative values''' ) return 2 * pi * radius * (height + radius) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> float: """simple docstring""" if torus_radius < 0 or tube_radius < 0: raise ValueError('''surface_area_torus() only accepts non-negative values''' ) if torus_radius < tube_radius: raise ValueError( '''surface_area_torus() does not support spindle or self intersecting tori''' ) return 4 * pow(_UpperCamelCase, 2 ) * torus_radius * tube_radius def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> float: """simple docstring""" if length < 0 or width < 0: raise ValueError('''area_rectangle() only accepts non-negative values''' ) return length * width def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> float: """simple docstring""" if side_length < 0: raise ValueError('''area_square() only accepts non-negative values''' ) return side_length**2 def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> float: """simple docstring""" if base < 0 or height < 0: raise ValueError('''area_triangle() only accepts non-negative values''' ) return (base * height) / 2 def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> float: """simple docstring""" if sidea < 0 or sidea < 0 or sidea < 0: raise ValueError('''area_triangle_three_sides() only accepts non-negative values''' ) elif sidea + sidea < sidea or sidea + sidea < sidea or sidea + sidea < sidea: raise ValueError('''Given three sides do not form a triangle''' ) a = (sidea + sidea + sidea) / 2 a = sqrt( semi_perimeter * (semi_perimeter - sidea) * (semi_perimeter - sidea) * (semi_perimeter - sidea) ) return area def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> float: """simple docstring""" if base < 0 or height < 0: raise ValueError('''area_parallelogram() only accepts non-negative values''' ) return base * height def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> float: """simple docstring""" if basea < 0 or basea < 0 or height < 0: raise ValueError('''area_trapezium() only accepts non-negative values''' ) return 1 / 2 * (basea + basea) * height def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> float: """simple docstring""" if radius < 0: raise ValueError('''area_circle() only accepts non-negative values''' ) return pi * radius**2 def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> float: """simple docstring""" if radius_x < 0 or radius_y < 0: raise ValueError('''area_ellipse() only accepts non-negative values''' ) return pi * radius_x * radius_y def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> float: """simple docstring""" if diagonal_a < 0 or diagonal_a < 0: raise ValueError('''area_rhombus() only accepts non-negative values''' ) return 1 / 2 * diagonal_a * diagonal_a def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> float: """simple docstring""" if not isinstance(_UpperCamelCase, _UpperCamelCase ) or sides < 3: raise ValueError( '''area_reg_polygon() only accepts integers greater than or \ equal to three as number of sides''' ) elif length < 0: raise ValueError( '''area_reg_polygon() only accepts non-negative values as \ length of a side''' ) return (sides * length**2) / (4 * tan(pi / sides )) return (sides * length**2) / (4 * tan(pi / sides )) if __name__ == "__main__": import doctest doctest.testmod(verbose=True) # verbose so we can see methods missing tests print("""[DEMO] Areas of various geometric shapes: \n""") print(F"Rectangle: {area_rectangle(10, 20) = }") print(F"Square: {area_square(10) = }") print(F"Triangle: {area_triangle(10, 10) = }") print(F"Triangle: {area_triangle_three_sides(5, 12, 13) = }") print(F"Parallelogram: {area_parallelogram(10, 20) = }") print(F"Rhombus: {area_rhombus(10, 20) = }") print(F"Trapezium: {area_trapezium(10, 20, 30) = }") print(F"Circle: {area_circle(20) = }") print(F"Ellipse: {area_ellipse(10, 20) = }") print("""\nSurface Areas of various geometric shapes: \n""") print(F"Cube: {surface_area_cube(20) = }") print(F"Cuboid: {surface_area_cuboid(10, 20, 30) = }") print(F"Sphere: {surface_area_sphere(20) = }") print(F"Hemisphere: {surface_area_hemisphere(20) = }") print(F"Cone: {surface_area_cone(10, 20) = }") print(F"Conical Frustum: {surface_area_conical_frustum(10, 20, 30) = }") print(F"Cylinder: {surface_area_cylinder(10, 20) = }") print(F"Torus: {surface_area_torus(20, 10) = }") print(F"Equilateral Triangle: {area_reg_polygon(3, 10) = }") print(F"Square: {area_reg_polygon(4, 10) = }") print(F"Reqular Pentagon: {area_reg_polygon(5, 10) = }")
359
def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Union[str, Any]: """simple docstring""" stooge(snake_case_, 0, len(snake_case_ ) - 1 ) return arr def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> Optional[Any]: """simple docstring""" if i >= h: return # If first element is smaller than the last then swap them if arr[i] > arr[h]: a , a = arr[h], arr[i] # If there are more than 2 elements in the array if h - i + 1 > 2: a = (int)((h - i + 1) / 3 ) # Recursively sort first 2/3 elements stooge(snake_case_, snake_case_, (h - t) ) # Recursively sort last 2/3 elements stooge(snake_case_, i + t, (snake_case_) ) # Recursively sort first 2/3 elements stooge(snake_case_, snake_case_, (h - t) ) if __name__ == "__main__": UpperCamelCase__ : Dict = input("""Enter numbers separated by a comma:\n""").strip() UpperCamelCase__ : Optional[int] = [int(item) for item in user_input.split(""",""")] print(stooge_sort(unsorted))
330
0
def SCREAMING_SNAKE_CASE__ ( snake_case_ = 1_0_0_0_0_0_0 ) -> int: """simple docstring""" a = limit + 1 a = [0] * limit for first_term in range(1, lowerCAmelCase__ ): for n in range(lowerCAmelCase__, lowerCAmelCase__, lowerCAmelCase__ ): a = first_term + n / first_term if common_difference % 4: # d must be divisble by 4 continue else: common_difference /= 4 if ( first_term > common_difference and first_term < 4 * common_difference ): # since x,y,z are positive integers frequency[n] += 1 # so z>0 and a>d ,also 4d<a a = sum(1 for x in frequency[1:limit] if x == 1_0 ) return count if __name__ == "__main__": print(F"{solution() = }")
360
import json import os import re import unicodedata from json.encoder import INFINITY from typing import Any, Dict, List, Optional, Tuple, Union import numpy as np import regex from ...tokenization_utils import AddedToken, PreTrainedTokenizer from ...tokenization_utils_base import BatchEncoding from ...utils import TensorType, is_flax_available, is_tf_available, is_torch_available, logging from ...utils.generic import _is_jax, _is_numpy UpperCamelCase__ : Any = logging.get_logger(__name__) UpperCamelCase__ : Optional[Any] = { """artists_file""": """artists.json""", """lyrics_file""": """lyrics.json""", """genres_file""": """genres.json""", } UpperCamelCase__ : Union[str, Any] = { """artists_file""": { """jukebox""": """https://huggingface.co/ArthurZ/jukebox/blob/main/artists.json""", }, """genres_file""": { """jukebox""": """https://huggingface.co/ArthurZ/jukebox/blob/main/genres.json""", }, """lyrics_file""": { """jukebox""": """https://huggingface.co/ArthurZ/jukebox/blob/main/lyrics.json""", }, } UpperCamelCase__ : str = { """jukebox""": 512, } class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = VOCAB_FILES_NAMES SCREAMING_SNAKE_CASE_ = PRETRAINED_VOCAB_FILES_MAP SCREAMING_SNAKE_CASE_ = PRETRAINED_LYRIC_TOKENS_SIZES SCREAMING_SNAKE_CASE_ = ['input_ids', 'attention_mask'] def __init__( self : Optional[Any] ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : List[Any] ,__lowerCamelCase : Tuple ,__lowerCamelCase : Union[str, Any]=["v3", "v2", "v2"] ,__lowerCamelCase : List[Any]=5_12 ,__lowerCamelCase : Tuple=5 ,__lowerCamelCase : List[Any]="<|endoftext|>" ,**__lowerCamelCase : List[str] ,): '''simple docstring''' a = AddedToken(__lowerCamelCase ,lstrip=__lowerCamelCase ,rstrip=__lowerCamelCase ) if isinstance(__lowerCamelCase ,__lowerCamelCase ) else unk_token super().__init__( unk_token=__lowerCamelCase ,n_genres=__lowerCamelCase ,version=__lowerCamelCase ,max_n_lyric_tokens=__lowerCamelCase ,**__lowerCamelCase ,) a = version a = max_n_lyric_tokens a = n_genres with open(__lowerCamelCase ,encoding='''utf-8''' ) as vocab_handle: a = json.load(__lowerCamelCase ) with open(__lowerCamelCase ,encoding='''utf-8''' ) as vocab_handle: a = json.load(__lowerCamelCase ) with open(__lowerCamelCase ,encoding='''utf-8''' ) as vocab_handle: a = json.load(__lowerCamelCase ) a = r'''[^A-Za-z0-9.,:;!?\-\'\"()\[\] \t\n]+''' # In v2, we had a n_vocab=80 and in v3 we missed + and so n_vocab=79 of characters. if len(self.lyrics_encoder ) == 79: a = oov.replace(r'''\-\'''' ,r'''\-+\'''' ) a = regex.compile(__lowerCamelCase ) a = {v: k for k, v in self.artists_encoder.items()} a = {v: k for k, v in self.genres_encoder.items()} a = {v: k for k, v in self.lyrics_encoder.items()} @property def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' return len(self.artists_encoder ) + len(self.genres_encoder ) + len(self.lyrics_encoder ) def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ): '''simple docstring''' return dict(self.artists_encoder ,self.genres_encoder ,self.lyrics_encoder ) def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : Optional[int] ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : List[Any] ): '''simple docstring''' a = [self.artists_encoder.get(__lowerCamelCase ,0 ) for artist in list_artists] for genres in range(len(__lowerCamelCase ) ): a = [self.genres_encoder.get(__lowerCamelCase ,0 ) for genre in list_genres[genres]] a = list_genres[genres] + [-1] * (self.n_genres - len(list_genres[genres] )) a = [[self.lyrics_encoder.get(__lowerCamelCase ,0 ) for character in list_lyrics[0]], [], []] return artists_id, list_genres, lyric_ids def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : List[str] ): '''simple docstring''' return list(__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : List[Any] ,__lowerCamelCase : Any ,__lowerCamelCase : Optional[int] ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' a , a , a = self.prepare_for_tokenization(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ) a = self._tokenize(__lowerCamelCase ) return artist, genre, lyrics def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : str ,__lowerCamelCase : str ,__lowerCamelCase : str ,__lowerCamelCase : bool = False ): '''simple docstring''' for idx in range(len(self.version ) ): if self.version[idx] == "v3": a = artists[idx].lower() a = [genres[idx].lower()] else: a = self._normalize(artists[idx] ) + '''.v2''' a = [ self._normalize(__lowerCamelCase ) + '''.v2''' for genre in genres[idx].split('''_''' ) ] # split is for the full dictionary with combined genres if self.version[0] == "v2": a = regex.compile(r'''[^A-Za-z0-9.,:;!?\-\'\"()\[\] \t\n]+''' ) a = '''ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.,:;!?-+\'\"()[] \t\n''' a = {vocab[index]: index + 1 for index in range(len(__lowerCamelCase ) )} a = 0 a = len(__lowerCamelCase ) + 1 a = self.vocab a = {v: k for k, v in self.vocab.items()} a = '''''' else: a = regex.compile(r'''[^A-Za-z0-9.,:;!?\-+\'\"()\[\] \t\n]+''' ) a = self._run_strip_accents(__lowerCamelCase ) a = lyrics.replace('''\\''' ,'''\n''' ) a = self.out_of_vocab.sub('''''' ,__lowerCamelCase ), [], [] return artists, genres, lyrics def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : int ): '''simple docstring''' a = unicodedata.normalize('''NFD''' ,__lowerCamelCase ) a = [] for char in text: a = unicodedata.category(__lowerCamelCase ) if cat == "Mn": continue output.append(__lowerCamelCase ) return "".join(__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : str ): '''simple docstring''' a = ( [chr(__lowerCamelCase ) for i in range(ord('''a''' ) ,ord('''z''' ) + 1 )] + [chr(__lowerCamelCase ) for i in range(ord('''A''' ) ,ord('''Z''' ) + 1 )] + [chr(__lowerCamelCase ) for i in range(ord('''0''' ) ,ord('''9''' ) + 1 )] + ['''.'''] ) a = frozenset(__lowerCamelCase ) a = re.compile(r'''_+''' ) a = ''''''.join([c if c in accepted else '''_''' for c in text.lower()] ) a = pattern.sub('''_''' ,__lowerCamelCase ).strip('''_''' ) return text def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : List[str] ): '''simple docstring''' return " ".join(__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : str ,__lowerCamelCase : Optional[Union[str, TensorType]] = None ,__lowerCamelCase : bool = False ): '''simple docstring''' if not isinstance(__lowerCamelCase ,__lowerCamelCase ): a = TensorType(__lowerCamelCase ) # Get a function reference for the correct framework if tensor_type == TensorType.TENSORFLOW: if not is_tf_available(): raise ImportError( '''Unable to convert output to TensorFlow tensors format, TensorFlow is not installed.''' ) import tensorflow as tf a = tf.constant a = tf.is_tensor elif tensor_type == TensorType.PYTORCH: if not is_torch_available(): raise ImportError('''Unable to convert output to PyTorch tensors format, PyTorch is not installed.''' ) import torch a = torch.tensor a = torch.is_tensor elif tensor_type == TensorType.JAX: if not is_flax_available(): raise ImportError('''Unable to convert output to JAX tensors format, JAX is not installed.''' ) import jax.numpy as jnp # noqa: F811 a = jnp.array a = _is_jax else: a = np.asarray a = _is_numpy # Do the tensor conversion in batch try: if prepend_batch_axis: a = [inputs] if not is_tensor(__lowerCamelCase ): a = as_tensor(__lowerCamelCase ) except: # noqa E722 raise ValueError( '''Unable to create tensor, you should probably activate truncation and/or padding ''' '''with \'padding=True\' \'truncation=True\' to have batched tensors with the same length.''' ) return inputs def __call__( self : Tuple ,__lowerCamelCase : Tuple ,__lowerCamelCase : Optional[int] ,__lowerCamelCase : List[str]="" ,__lowerCamelCase : List[Any]="pt" ): '''simple docstring''' a = [0, 0, 0] a = [artist] * len(self.version ) a = [genres] * len(self.version ) a , a , a = self.tokenize(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ) a , a , a = self._convert_token_to_id(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ) a = [-INFINITY] * len(full_tokens[-1] ) a = [ self.convert_to_tensors( [input_ids + [artists_id[i]] + genres_ids[i] + full_tokens[i]] ,tensor_type=__lowerCamelCase ) for i in range(len(self.version ) ) ] return BatchEncoding({'''input_ids''': input_ids, '''attention_masks''': attention_masks} ) def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : str ,__lowerCamelCase : Optional[str] = None ): '''simple docstring''' if not os.path.isdir(__lowerCamelCase ): logger.error(F"""Vocabulary path ({save_directory}) should be a directory""" ) return a = os.path.join( __lowerCamelCase ,(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''artists_file'''] ) with open(__lowerCamelCase ,'''w''' ,encoding='''utf-8''' ) as f: f.write(json.dumps(self.artists_encoder ,ensure_ascii=__lowerCamelCase ) ) a = os.path.join( __lowerCamelCase ,(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''genres_file'''] ) with open(__lowerCamelCase ,'''w''' ,encoding='''utf-8''' ) as f: f.write(json.dumps(self.genres_encoder ,ensure_ascii=__lowerCamelCase ) ) a = os.path.join( __lowerCamelCase ,(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''lyrics_file'''] ) with open(__lowerCamelCase ,'''w''' ,encoding='''utf-8''' ) as f: f.write(json.dumps(self.lyrics_encoder ,ensure_ascii=__lowerCamelCase ) ) return (artists_file, genres_file, lyrics_file) def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : Any ,__lowerCamelCase : Any ,__lowerCamelCase : str ): '''simple docstring''' a = self.artists_decoder.get(__lowerCamelCase ) a = [self.genres_decoder.get(__lowerCamelCase ) for genre in genres_index] a = [self.lyrics_decoder.get(__lowerCamelCase ) for character in lyric_index] return artist, genres, lyrics
330
0
from typing import List, Optional, Union import numpy as np import tensorflow as tf from .utils import logging UpperCamelCase__ : List[str] = logging.get_logger(__name__) def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> List[int]: """simple docstring""" if isinstance(a__, np.ndarray ): return list(tensor.shape ) a = tf.shape(a__ ) if tensor.shape == tf.TensorShape(a__ ): return dynamic a = tensor.shape.as_list() return [dynamic[i] if s is None else s for i, s in enumerate(a__ )] def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ = None, snake_case_ = None ) -> tf.Tensor: """simple docstring""" return tf.nn.softmax(logits=logits + 1e-9, axis=a__, name=a__ ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_=1e-5, snake_case_=-1 ) -> List[str]: """simple docstring""" if weight.shape.rank != 1 or bias.shape.rank != 1 or not isinstance(a__, a__ ): raise NotImplementedError('''Only 1D weight and bias tensors are supported for now, with only a single axis.''' ) # Get mean and variance on the axis to be normalized a , a = tf.nn.moments(a__, axes=[axis], keepdims=a__ ) if axis != -1: # Reshape scale and weight to have the same rank as inputs, but with 1 dimensions # on every dimension except axis a = [1] * inputs.shape.rank a = shape_list(a__ )[axis] a = tf.reshape(a__, a__ ) a = tf.reshape(a__, a__ ) # Compute layer normalization using the batch_normalization # function. a = tf.nn.batch_normalization( a__, a__, a__, offset=a__, scale=a__, variance_epsilon=a__, ) return outputs def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_=0, snake_case_=-1 ) -> List[str]: """simple docstring""" if end_dim < 0: end_dim += input.shape.rank if start_dim < 0: start_dim += input.shape.rank if start_dim == end_dim: return input a = tf.shape(a__ ) a = tf.math.reduce_prod(in_shape[start_dim : end_dim + 1] ) a = tf.concat([in_shape[:start_dim], [flattened_dim], in_shape[end_dim + 1 :]], axis=0 ) return tf.reshape(a__, a__ ) def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> tf.Tensor: """simple docstring""" if not isinstance(a__, tf.Tensor ): a = tf.convert_to_tensor(a__ ) # Catches stray NumPy inputs if encoder_attention_mask.shape.rank == 3: a = encoder_attention_mask[:, None, :, :] if encoder_attention_mask.shape.rank == 2: a = encoder_attention_mask[:, None, None, :] # T5 has a mask that can compare sequence ids, we can simulate this here with this transposition # Cf. https://github.com/tensorflow/mesh/blob/8d2465e9bc93129b913b5ccc6a59aa97abd96ec6/mesh_tensorflow # /transformer/transformer_layers.py#L270 # encoder_extended_attention_mask = (encoder_extended_attention_mask == # encoder_extended_attention_mask.transpose(-1, -2)) a = ( tf.cast(1, encoder_attention_mask.dtype ) - encoder_extended_attention_mask ) * encoder_extended_attention_mask.dtype.min return encoder_extended_attention_mask def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ = "input_ids" ) -> None: """simple docstring""" tf.debugging.assert_less( a__, tf.cast(a__, dtype=tensor.dtype ), message=( f"""The maximum value of {tensor_name} ({tf.math.reduce_max(a__ )}) must be smaller than the embedding """ f"""layer's input dimension ({embed_dim}). The likely cause is some problem at tokenization time.""" ), ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> int: """simple docstring""" a = 6_4_5_1_2 # Check that no item in `data` is larger than `HDF5_OBJECT_HEADER_LIMIT` # because in that case even chunking the array would not make the saving # possible. a = [x for x in data if len(a__ ) > HDF5_OBJECT_HEADER_LIMIT] # Expecting this to never be true. if bad_attributes: raise RuntimeError( '''The following attributes cannot be saved to HDF5 file because ''' f"""they are larger than {HDF5_OBJECT_HEADER_LIMIT} """ f"""bytes: {bad_attributes}""" ) a = np.asarray(a__ ) a = 1 a = np.array_split(a__, a__ ) # This will never loop forever thanks to the test above. while any(x.nbytes > HDF5_OBJECT_HEADER_LIMIT for x in chunked_data ): num_chunks += 1 a = np.array_split(a__, a__ ) if num_chunks > 1: for chunk_id, chunk_data in enumerate(a__ ): a = chunk_data else: a = data def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> str: """simple docstring""" if name in group.attrs: a = [n.decode('''utf8''' ) if hasattr(a__, '''decode''' ) else n for n in group.attrs[name]] else: a = [] a = 0 while "%s%d" % (name, chunk_id) in group.attrs: data.extend( [n.decode('''utf8''' ) if hasattr(a__, '''decode''' ) else n for n in group.attrs['''%s%d''' % (name, chunk_id)]] ) chunk_id += 1 return data def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> List[str]: """simple docstring""" def _expand_single_ad_tensor(snake_case_ ): if isinstance(a__, tf.Tensor ) and t.shape.rank == 1: return tf.expand_dims(a__, axis=-1 ) return t return tf.nest.map_structure(_expand_single_ad_tensor, a__ )
361
# This script creates a super tiny model that is useful inside tests, when we just want to test that # the machinery works, without needing to the check the quality of the outcomes. # # This version creates a tiny vocab first, and then a tiny model - so the outcome is truly tiny - # all files ~60KB. As compared to taking a full-size model, reducing to the minimum its layers and # emb dimensions, but keeping the full vocab + merges files, leading to ~3MB in total for all files. # The latter is done by `fsmt-make-super-tiny-model.py`. # # It will be used then as "stas/tiny-wmt19-en-ru" from pathlib import Path import json import tempfile from transformers import FSMTTokenizer, FSMTConfig, FSMTForConditionalGeneration from transformers.models.fsmt.tokenization_fsmt import VOCAB_FILES_NAMES UpperCamelCase__ : Optional[Any] = """tiny-wmt19-en-ru""" # Build # borrowed from a test UpperCamelCase__ : Any = [ """l""", """o""", """w""", """e""", """r""", """s""", """t""", """i""", """d""", """n""", """w</w>""", """r</w>""", """t</w>""", """lo""", """low""", """er</w>""", """low</w>""", """lowest</w>""", """newer</w>""", """wider</w>""", """<unk>""", ] UpperCamelCase__ : List[Any] = dict(zip(vocab, range(len(vocab)))) UpperCamelCase__ : Any = ["""l o 123""", """lo w 1456""", """e r</w> 1789""", """"""] with tempfile.TemporaryDirectory() as tmpdirname: UpperCamelCase__ : Optional[Any] = Path(tmpdirname) UpperCamelCase__ : Tuple = build_dir / VOCAB_FILES_NAMES["""src_vocab_file"""] UpperCamelCase__ : int = build_dir / VOCAB_FILES_NAMES["""tgt_vocab_file"""] UpperCamelCase__ : Union[str, Any] = build_dir / VOCAB_FILES_NAMES["""merges_file"""] with open(src_vocab_file, """w""") as fp: fp.write(json.dumps(vocab_tokens)) with open(tgt_vocab_file, """w""") as fp: fp.write(json.dumps(vocab_tokens)) with open(merges_file, """w""") as fp: fp.write("""\n""".join(merges)) UpperCamelCase__ : Dict = FSMTTokenizer( langs=["""en""", """ru"""], src_vocab_size=len(vocab), tgt_vocab_size=len(vocab), src_vocab_file=src_vocab_file, tgt_vocab_file=tgt_vocab_file, merges_file=merges_file, ) UpperCamelCase__ : Union[str, Any] = FSMTConfig( langs=["""ru""", """en"""], src_vocab_size=1_000, tgt_vocab_size=1_000, d_model=4, encoder_layers=1, decoder_layers=1, encoder_ffn_dim=4, decoder_ffn_dim=4, encoder_attention_heads=1, decoder_attention_heads=1, ) UpperCamelCase__ : Union[str, Any] = FSMTForConditionalGeneration(config) print(F"num of params {tiny_model.num_parameters()}") # Test UpperCamelCase__ : List[str] = tokenizer(["""Making tiny model"""], return_tensors="""pt""") UpperCamelCase__ : Tuple = tiny_model(**batch) print("""test output:""", len(outputs.logits[0])) # Save tiny_model.half() # makes it smaller tiny_model.save_pretrained(mname_tiny) tokenizer.save_pretrained(mname_tiny) print(F"Generated {mname_tiny}") # Upload # transformers-cli upload tiny-wmt19-en-ru
330
0
import argparse import json from pathlib import Path import requests import torch from huggingface_hub import cached_download, hf_hub_url from PIL import Image from transformers import DPTConfig, DPTForDepthEstimation, DPTForSemanticSegmentation, DPTImageProcessor from transformers.utils import logging logging.set_verbosity_info() UpperCamelCase__ : Optional[Any] = logging.get_logger(__name__) def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Tuple: """simple docstring""" a = DPTConfig() if "large" in checkpoint_url: a = 1_0_2_4 a = 4_0_9_6 a = 2_4 a = 1_6 a = [5, 1_1, 1_7, 2_3] a = [2_5_6, 5_1_2, 1_0_2_4, 1_0_2_4] a = (1, 3_8_4, 3_8_4) if "ade" in checkpoint_url: a = True a = 1_5_0 a = '''huggingface/label-files''' a = '''ade20k-id2label.json''' a = json.load(open(cached_download(hf_hub_url(lowercase_, lowercase_, repo_type='''dataset''' ) ), '''r''' ) ) a = {int(lowercase_ ): v for k, v in idalabel.items()} a = idalabel a = {v: k for k, v in idalabel.items()} a = [1, 1_5_0, 4_8_0, 4_8_0] return config, expected_shape def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Optional[int]: """simple docstring""" a = ['''pretrained.model.head.weight''', '''pretrained.model.head.bias'''] for k in ignore_keys: state_dict.pop(lowercase_, lowercase_ ) def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Dict: """simple docstring""" if ( "pretrained.model" in name and "cls_token" not in name and "pos_embed" not in name and "patch_embed" not in name ): a = name.replace('''pretrained.model''', '''dpt.encoder''' ) if "pretrained.model" in name: a = name.replace('''pretrained.model''', '''dpt.embeddings''' ) if "patch_embed" in name: a = name.replace('''patch_embed''', '''patch_embeddings''' ) if "pos_embed" in name: a = name.replace('''pos_embed''', '''position_embeddings''' ) if "attn.proj" in name: a = name.replace('''attn.proj''', '''attention.output.dense''' ) if "proj" in name and "project" not in name: a = name.replace('''proj''', '''projection''' ) if "blocks" in name: a = name.replace('''blocks''', '''layer''' ) if "mlp.fc1" in name: a = name.replace('''mlp.fc1''', '''intermediate.dense''' ) if "mlp.fc2" in name: a = name.replace('''mlp.fc2''', '''output.dense''' ) if "norm1" in name: a = name.replace('''norm1''', '''layernorm_before''' ) if "norm2" in name: a = name.replace('''norm2''', '''layernorm_after''' ) if "scratch.output_conv" in name: a = name.replace('''scratch.output_conv''', '''head''' ) if "scratch" in name: a = name.replace('''scratch''', '''neck''' ) if "layer1_rn" in name: a = name.replace('''layer1_rn''', '''convs.0''' ) if "layer2_rn" in name: a = name.replace('''layer2_rn''', '''convs.1''' ) if "layer3_rn" in name: a = name.replace('''layer3_rn''', '''convs.2''' ) if "layer4_rn" in name: a = name.replace('''layer4_rn''', '''convs.3''' ) if "refinenet" in name: a = int(name[len('''neck.refinenet''' ) : len('''neck.refinenet''' ) + 1] ) # tricky here: we need to map 4 to 0, 3 to 1, 2 to 2 and 1 to 3 a = name.replace(f"""refinenet{layer_idx}""", f"""fusion_stage.layers.{abs(layer_idx-4 )}""" ) if "out_conv" in name: a = name.replace('''out_conv''', '''projection''' ) if "resConfUnit1" in name: a = name.replace('''resConfUnit1''', '''residual_layer1''' ) if "resConfUnit2" in name: a = name.replace('''resConfUnit2''', '''residual_layer2''' ) if "conv1" in name: a = name.replace('''conv1''', '''convolution1''' ) if "conv2" in name: a = name.replace('''conv2''', '''convolution2''' ) # readout blocks if "pretrained.act_postprocess1.0.project.0" in name: a = name.replace('''pretrained.act_postprocess1.0.project.0''', '''neck.reassemble_stage.readout_projects.0.0''' ) if "pretrained.act_postprocess2.0.project.0" in name: a = name.replace('''pretrained.act_postprocess2.0.project.0''', '''neck.reassemble_stage.readout_projects.1.0''' ) if "pretrained.act_postprocess3.0.project.0" in name: a = name.replace('''pretrained.act_postprocess3.0.project.0''', '''neck.reassemble_stage.readout_projects.2.0''' ) if "pretrained.act_postprocess4.0.project.0" in name: a = name.replace('''pretrained.act_postprocess4.0.project.0''', '''neck.reassemble_stage.readout_projects.3.0''' ) # resize blocks if "pretrained.act_postprocess1.3" in name: a = name.replace('''pretrained.act_postprocess1.3''', '''neck.reassemble_stage.layers.0.projection''' ) if "pretrained.act_postprocess1.4" in name: a = name.replace('''pretrained.act_postprocess1.4''', '''neck.reassemble_stage.layers.0.resize''' ) if "pretrained.act_postprocess2.3" in name: a = name.replace('''pretrained.act_postprocess2.3''', '''neck.reassemble_stage.layers.1.projection''' ) if "pretrained.act_postprocess2.4" in name: a = name.replace('''pretrained.act_postprocess2.4''', '''neck.reassemble_stage.layers.1.resize''' ) if "pretrained.act_postprocess3.3" in name: a = name.replace('''pretrained.act_postprocess3.3''', '''neck.reassemble_stage.layers.2.projection''' ) if "pretrained.act_postprocess4.3" in name: a = name.replace('''pretrained.act_postprocess4.3''', '''neck.reassemble_stage.layers.3.projection''' ) if "pretrained.act_postprocess4.4" in name: a = name.replace('''pretrained.act_postprocess4.4''', '''neck.reassemble_stage.layers.3.resize''' ) if "pretrained" in name: a = name.replace('''pretrained''', '''dpt''' ) if "bn" in name: a = name.replace('''bn''', '''batch_norm''' ) if "head" in name: a = name.replace('''head''', '''head.head''' ) if "encoder.norm" in name: a = name.replace('''encoder.norm''', '''layernorm''' ) if "auxlayer" in name: a = name.replace('''auxlayer''', '''auxiliary_head.head''' ) return name def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> int: """simple docstring""" for i in range(config.num_hidden_layers ): # read in weights + bias of input projection layer (in timm, this is a single matrix + bias) a = state_dict.pop(f"""dpt.encoder.layer.{i}.attn.qkv.weight""" ) a = state_dict.pop(f"""dpt.encoder.layer.{i}.attn.qkv.bias""" ) # next, add query, keys and values (in that order) to the state dict a = in_proj_weight[: config.hidden_size, :] a = in_proj_bias[: config.hidden_size] a = in_proj_weight[ config.hidden_size : config.hidden_size * 2, : ] a = in_proj_bias[ config.hidden_size : config.hidden_size * 2 ] a = in_proj_weight[ -config.hidden_size :, : ] a = in_proj_bias[-config.hidden_size :] def SCREAMING_SNAKE_CASE__ ( ) -> Tuple: """simple docstring""" a = '''http://images.cocodataset.org/val2017/000000039769.jpg''' a = Image.open(requests.get(lowercase_, stream=lowercase_ ).raw ) return im @torch.no_grad() def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_ ) -> Tuple: """simple docstring""" a , a = get_dpt_config(lowercase_ ) # load original state_dict from URL a = torch.hub.load_state_dict_from_url(lowercase_, map_location='''cpu''' ) # remove certain keys remove_ignore_keys_(lowercase_ ) # rename keys for key in state_dict.copy().keys(): a = state_dict.pop(lowercase_ ) a = val # read in qkv matrices read_in_q_k_v(lowercase_, lowercase_ ) # load HuggingFace model a = DPTForSemanticSegmentation(lowercase_ ) if '''ade''' in checkpoint_url else DPTForDepthEstimation(lowercase_ ) model.load_state_dict(lowercase_ ) model.eval() # Check outputs on an image a = 4_8_0 if '''ade''' in checkpoint_url else 3_8_4 a = DPTImageProcessor(size=lowercase_ ) a = prepare_img() a = image_processor(lowercase_, return_tensors='''pt''' ) # forward pass a = model(**lowercase_ ).logits if '''ade''' in checkpoint_url else model(**lowercase_ ).predicted_depth # Assert logits a = torch.tensor([[6.3199, 6.3629, 6.4148], [6.3850, 6.3615, 6.4166], [6.3519, 6.3176, 6.3575]] ) if "ade" in checkpoint_url: a = torch.tensor([[4.0480, 4.2420, 4.4360], [4.3124, 4.5693, 4.8261], [4.5768, 4.8965, 5.2163]] ) assert outputs.shape == torch.Size(lowercase_ ) assert ( torch.allclose(outputs[0, 0, :3, :3], lowercase_, atol=1e-4 ) if "ade" in checkpoint_url else torch.allclose(outputs[0, :3, :3], lowercase_ ) ) Path(lowercase_ ).mkdir(exist_ok=lowercase_ ) print(f"""Saving model to {pytorch_dump_folder_path}""" ) model.save_pretrained(lowercase_ ) print(f"""Saving image processor to {pytorch_dump_folder_path}""" ) image_processor.save_pretrained(lowercase_ ) if push_to_hub: print('''Pushing model to hub...''' ) model.push_to_hub( repo_path_or_name=Path(lowercase_, lowercase_ ), organization='''nielsr''', commit_message='''Add model''', use_temp_dir=lowercase_, ) image_processor.push_to_hub( repo_path_or_name=Path(lowercase_, lowercase_ ), organization='''nielsr''', commit_message='''Add image processor''', use_temp_dir=lowercase_, ) if __name__ == "__main__": UpperCamelCase__ : Tuple = argparse.ArgumentParser() # Required parameters parser.add_argument( """--checkpoint_url""", default="""https://github.com/intel-isl/DPT/releases/download/1_0/dpt_large-midas-2f21e586.pt""", type=str, help="""URL of the original DPT checkpoint you\'d like to convert.""", ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model directory.""", ) parser.add_argument( """--push_to_hub""", action="""store_true""", ) parser.add_argument( """--model_name""", default="""dpt-large""", type=str, help="""Name of the model, in case you\'re pushing to the hub.""", ) UpperCamelCase__ : Optional[Any] = parser.parse_args() convert_dpt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub, args.model_name)
362
import inspect import os import torch from transformers import AutoModel from transformers.testing_utils import mockenv_context from transformers.trainer_utils import set_seed import accelerate from accelerate.accelerator import Accelerator from accelerate.state import AcceleratorState from accelerate.test_utils.testing import ( AccelerateTestCase, TempDirTestCase, execute_subprocess_async, require_cuda, require_fsdp, require_multi_gpu, slow, ) from accelerate.utils.constants import ( FSDP_AUTO_WRAP_POLICY, FSDP_BACKWARD_PREFETCH, FSDP_SHARDING_STRATEGY, FSDP_STATE_DICT_TYPE, ) from accelerate.utils.dataclasses import FullyShardedDataParallelPlugin from accelerate.utils.other import patch_environment set_seed(42) UpperCamelCase__ : Optional[Any] = """bert-base-cased""" UpperCamelCase__ : int = """fp16""" UpperCamelCase__ : str = """bf16""" UpperCamelCase__ : List[Any] = [FPaa, BFaa] @require_fsdp @require_cuda class lowerCamelCase_ ( a_ ): def SCREAMING_SNAKE_CASE_ ( self : int ): '''simple docstring''' super().setUp() a = dict( ACCELERATE_USE_FSDP='''true''' ,MASTER_ADDR='''localhost''' ,MASTER_PORT='''10999''' ,RANK='''0''' ,LOCAL_RANK='''0''' ,WORLD_SIZE='''1''' ,) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import ShardingStrategy for i, strategy in enumerate(__lowerCamelCase ): a = self.dist_env.copy() a = F"""{i + 1}""" a = strategy with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() self.assertEqual(fsdp_plugin.sharding_strategy ,ShardingStrategy(i + 1 ) ) def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import BackwardPrefetch for i, prefetch_policy in enumerate(__lowerCamelCase ): a = self.dist_env.copy() a = prefetch_policy with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() if prefetch_policy == "NO_PREFETCH": self.assertIsNone(fsdp_plugin.backward_prefetch ) else: self.assertEqual(fsdp_plugin.backward_prefetch ,BackwardPrefetch(i + 1 ) ) def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType for i, state_dict_type in enumerate(__lowerCamelCase ): a = self.dist_env.copy() a = state_dict_type with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() self.assertEqual(fsdp_plugin.state_dict_type ,StateDictType(i + 1 ) ) if state_dict_type == "FULL_STATE_DICT": self.assertTrue(fsdp_plugin.state_dict_config.offload_to_cpu ) self.assertTrue(fsdp_plugin.state_dict_config.ranka_only ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ): '''simple docstring''' a = AutoModel.from_pretrained(__lowerCamelCase ) for policy in FSDP_AUTO_WRAP_POLICY: a = self.dist_env.copy() a = policy if policy == "TRANSFORMER_BASED_WRAP": a = '''BertLayer''' elif policy == "SIZE_BASED_WRAP": a = '''2000''' with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() fsdp_plugin.set_auto_wrap_policy(__lowerCamelCase ) if policy == "NO_WRAP": self.assertIsNone(fsdp_plugin.auto_wrap_policy ) else: self.assertIsNotNone(fsdp_plugin.auto_wrap_policy ) a = self.dist_env.copy() a = '''TRANSFORMER_BASED_WRAP''' a = '''T5Layer''' with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() with self.assertRaises(__lowerCamelCase ) as cm: fsdp_plugin.set_auto_wrap_policy(__lowerCamelCase ) self.assertTrue('''Could not find the transformer layer class to wrap in the model.''' in str(cm.exception ) ) a = self.dist_env.copy() a = '''SIZE_BASED_WRAP''' a = '''0''' with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() fsdp_plugin.set_auto_wrap_policy(__lowerCamelCase ) self.assertIsNone(fsdp_plugin.auto_wrap_policy ) def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import MixedPrecision from torch.distributed.fsdp.sharded_grad_scaler import ShardedGradScaler for mp_dtype in dtypes: a = self.dist_env.copy() a = mp_dtype with mockenv_context(**__lowerCamelCase ): a = Accelerator() if mp_dtype == "fp16": a = torch.floataa elif mp_dtype == "bf16": a = torch.bfloataa a = MixedPrecision(param_dtype=__lowerCamelCase ,reduce_dtype=__lowerCamelCase ,buffer_dtype=__lowerCamelCase ) self.assertEqual(accelerator.state.fsdp_plugin.mixed_precision_policy ,__lowerCamelCase ) if mp_dtype == FPaa: self.assertTrue(isinstance(accelerator.scaler ,__lowerCamelCase ) ) elif mp_dtype == BFaa: self.assertIsNone(accelerator.scaler ) AcceleratorState._reset_state(__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import CPUOffload for flag in [True, False]: a = self.dist_env.copy() a = str(__lowerCamelCase ).lower() with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() self.assertEqual(fsdp_plugin.cpu_offload ,CPUOffload(offload_params=__lowerCamelCase ) ) @require_fsdp @require_multi_gpu @slow class lowerCamelCase_ ( a_ ): def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' super().setUp() a = 0.82 a = [ '''fsdp_shard_grad_op_transformer_based_wrap''', '''fsdp_full_shard_transformer_based_wrap''', ] a = { '''multi_gpu_fp16''': 32_00, '''fsdp_shard_grad_op_transformer_based_wrap_fp16''': 20_00, '''fsdp_full_shard_transformer_based_wrap_fp16''': 19_00, # Disabling below test as it overwhelms the RAM memory usage # on CI self-hosted runner leading to tests getting killed. # "fsdp_full_shard_cpu_offload_transformer_based_wrap_fp32": 1500, # fp16 was leading to indefinite hang } a = 1_60 a = 1_60 a = inspect.getfile(accelerate.test_utils ) a = os.path.sep.join(mod_file.split(os.path.sep )[:-1] + ['''scripts''', '''external_deps'''] ) def SCREAMING_SNAKE_CASE_ ( self : List[str] ): '''simple docstring''' a = os.path.join(self.test_scripts_folder ,'''test_performance.py''' ) a = ['''accelerate''', '''launch''', '''--num_processes=2''', '''--num_machines=1''', '''--machine_rank=0''', '''--use_fsdp'''] for config in self.performance_configs: a = cmd.copy() for i, strategy in enumerate(__lowerCamelCase ): if strategy.lower() in config: cmd_config.append(F"""--fsdp_sharding_strategy={i+1}""" ) break if "fp32" in config: cmd_config.append('''--mixed_precision=no''' ) else: cmd_config.append('''--mixed_precision=fp16''' ) if "cpu_offload" in config: cmd_config.append('''--fsdp_offload_params=True''' ) for policy in FSDP_AUTO_WRAP_POLICY: if policy.lower() in config: cmd_config.append(F"""--fsdp_auto_wrap_policy={policy}""" ) break if policy == "TRANSFORMER_BASED_WRAP": cmd_config.append('''--fsdp_transformer_layer_cls_to_wrap=BertLayer''' ) elif policy == "SIZE_BASED_WRAP": cmd_config.append('''--fsdp_min_num_params=2000''' ) cmd_config.extend( [ self.test_file_path, F"""--output_dir={self.tmpdir}""", F"""--performance_lower_bound={self.performance_lower_bound}""", ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(__lowerCamelCase ,env=os.environ.copy() ) def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' a = os.path.join(self.test_scripts_folder ,'''test_checkpointing.py''' ) a = [ '''accelerate''', '''launch''', '''--num_processes=2''', '''--num_machines=1''', '''--machine_rank=0''', '''--use_fsdp''', '''--mixed_precision=fp16''', '''--fsdp_transformer_layer_cls_to_wrap=BertLayer''', ] for i, strategy in enumerate(__lowerCamelCase ): a = cmd.copy() cmd_config.append(F"""--fsdp_sharding_strategy={i+1}""" ) if strategy != "FULL_SHARD": continue a = len(__lowerCamelCase ) for state_dict_type in FSDP_STATE_DICT_TYPE: a = cmd_config[:state_dict_config_index] cmd_config.append(F"""--fsdp_state_dict_type={state_dict_type}""" ) cmd_config.extend( [ self.test_file_path, F"""--output_dir={self.tmpdir}""", '''--partial_train_epoch=1''', ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(__lowerCamelCase ,env=os.environ.copy() ) a = cmd_config[:-1] a = os.path.join(self.tmpdir ,'''epoch_0''' ) cmd_config.extend( [ F"""--resume_from_checkpoint={resume_from_checkpoint}""", ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(__lowerCamelCase ,env=os.environ.copy() ) def SCREAMING_SNAKE_CASE_ ( self : int ): '''simple docstring''' a = os.path.join(self.test_scripts_folder ,'''test_peak_memory_usage.py''' ) a = [ '''accelerate''', '''launch''', '''--num_processes=2''', '''--num_machines=1''', '''--machine_rank=0''', ] for spec, peak_mem_upper_bound in self.peak_memory_usage_upper_bound.items(): a = cmd.copy() if "fp16" in spec: cmd_config.extend(['''--mixed_precision=fp16'''] ) else: cmd_config.extend(['''--mixed_precision=no'''] ) if "multi_gpu" in spec: continue else: cmd_config.extend(['''--use_fsdp'''] ) for i, strategy in enumerate(__lowerCamelCase ): if strategy.lower() in spec: cmd_config.append(F"""--fsdp_sharding_strategy={i+1}""" ) break if "cpu_offload" in spec: cmd_config.append('''--fsdp_offload_params=True''' ) for policy in FSDP_AUTO_WRAP_POLICY: if policy.lower() in spec: cmd_config.append(F"""--fsdp_auto_wrap_policy={policy}""" ) break if policy == "TRANSFORMER_BASED_WRAP": cmd_config.append('''--fsdp_transformer_layer_cls_to_wrap=BertLayer''' ) elif policy == "SIZE_BASED_WRAP": cmd_config.append('''--fsdp_min_num_params=2000''' ) cmd_config.extend( [ self.test_file_path, F"""--output_dir={self.tmpdir}""", F"""--peak_memory_upper_bound={peak_mem_upper_bound}""", F"""--n_train={self.n_train}""", F"""--n_val={self.n_val}""", ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(__lowerCamelCase ,env=os.environ.copy() )
330
0
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available UpperCamelCase__ : Optional[Any] = { """configuration_conditional_detr""": [ """CONDITIONAL_DETR_PRETRAINED_CONFIG_ARCHIVE_MAP""", """ConditionalDetrConfig""", """ConditionalDetrOnnxConfig""", ] } try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCamelCase__ : List[Any] = ["""ConditionalDetrFeatureExtractor"""] UpperCamelCase__ : Dict = ["""ConditionalDetrImageProcessor"""] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCamelCase__ : Dict = [ """CONDITIONAL_DETR_PRETRAINED_MODEL_ARCHIVE_LIST""", """ConditionalDetrForObjectDetection""", """ConditionalDetrForSegmentation""", """ConditionalDetrModel""", """ConditionalDetrPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_conditional_detr import ( CONDITIONAL_DETR_PRETRAINED_CONFIG_ARCHIVE_MAP, ConditionalDetrConfig, ConditionalDetrOnnxConfig, ) try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_conditional_detr import ConditionalDetrFeatureExtractor from .image_processing_conditional_detr import ConditionalDetrImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_conditional_detr import ( CONDITIONAL_DETR_PRETRAINED_MODEL_ARCHIVE_LIST, ConditionalDetrForObjectDetection, ConditionalDetrForSegmentation, ConditionalDetrModel, ConditionalDetrPreTrainedModel, ) else: import sys UpperCamelCase__ : List[str] = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
363
from __future__ import annotations import os from collections.abc import Mapping UpperCamelCase__ : Any = tuple[int, int] class lowerCamelCase_ : def __init__( self : Optional[Any] ,__lowerCamelCase : set[int] ,__lowerCamelCase : Mapping[EdgeT, int] ): '''simple docstring''' a = vertices a = { (min(__lowerCamelCase ), max(__lowerCamelCase )): weight for edge, weight in edges.items() } def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : EdgeT ,__lowerCamelCase : int ): '''simple docstring''' self.vertices.add(edge[0] ) self.vertices.add(edge[1] ) a = weight def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' a = Graph({min(self.vertices )} ,{} ) a = 42 a = 42 a = 42 a = 42 while len(subgraph.vertices ) < len(self.vertices ): a = max(self.edges.values() ) + 1 for edge, weight in self.edges.items(): if (edge[0] in subgraph.vertices) ^ (edge[1] in subgraph.vertices): if weight < min_weight: a = edge a = weight subgraph.add_edge(__lowerCamelCase ,__lowerCamelCase ) return subgraph def SCREAMING_SNAKE_CASE__ ( snake_case_ = "p107_network.txt" ) -> int: """simple docstring""" a = os.path.abspath(os.path.dirname(snake_case_ ) ) a = os.path.join(snake_case_, snake_case_ ) a = {} a = 42 a = 42 a = 42 with open(snake_case_ ) as f: a = f.read().strip().split('''\n''' ) a = [line.split(''',''' ) for line in data] for edgea in range(1, len(snake_case_ ) ): for edgea in range(snake_case_ ): if adjaceny_matrix[edgea][edgea] != "-": a = int(adjaceny_matrix[edgea][edgea] ) a = Graph(set(range(len(snake_case_ ) ) ), snake_case_ ) a = graph.prims_algorithm() a = sum(graph.edges.values() ) a = sum(subgraph.edges.values() ) return initial_total - optimal_total if __name__ == "__main__": print(F"{solution() = }")
330
0
from ...utils import ( OptionalDependencyNotAvailable, is_torch_available, is_transformers_available, is_transformers_version, ) try: if not (is_transformers_available() and is_torch_available() and is_transformers_version(""">=""", """4.25.0""")): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ...utils.dummy_torch_and_transformers_objects import ( VersatileDiffusionDualGuidedPipeline, VersatileDiffusionImageVariationPipeline, VersatileDiffusionPipeline, VersatileDiffusionTextToImagePipeline, ) else: from .modeling_text_unet import UNetFlatConditionModel from .pipeline_versatile_diffusion import VersatileDiffusionPipeline from .pipeline_versatile_diffusion_dual_guided import VersatileDiffusionDualGuidedPipeline from .pipeline_versatile_diffusion_image_variation import VersatileDiffusionImageVariationPipeline from .pipeline_versatile_diffusion_text_to_image import VersatileDiffusionTextToImagePipeline
364
from typing import Optional, Tuple, Union import tensorflow as tf from ...activations_tf import ACTaFN from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward from ...modeling_tf_outputs import ( TFBaseModelOutputWithNoAttention, TFBaseModelOutputWithPoolingAndNoAttention, TFSequenceClassifierOutput, ) from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs from ...tf_utils import shape_list from ...utils import logging from .configuration_regnet import RegNetConfig UpperCamelCase__ : List[Any] = logging.get_logger(__name__) # General docstring UpperCamelCase__ : List[Any] = """RegNetConfig""" # Base docstring UpperCamelCase__ : Dict = """facebook/regnet-y-040""" UpperCamelCase__ : int = [1, 1_088, 7, 7] # Image classification docstring UpperCamelCase__ : Optional[Any] = """facebook/regnet-y-040""" UpperCamelCase__ : Dict = """tabby, tabby cat""" UpperCamelCase__ : Dict = [ """facebook/regnet-y-040""", # See all regnet models at https://huggingface.co/models?filter=regnet ] class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : List[str] ,__lowerCamelCase : int ,__lowerCamelCase : int = 3 ,__lowerCamelCase : int = 1 ,__lowerCamelCase : int = 1 ,__lowerCamelCase : Optional[str] = "relu" ,**__lowerCamelCase : str ,): '''simple docstring''' super().__init__(**__lowerCamelCase ) # The padding and conv has been verified in # https://colab.research.google.com/gist/sayakpaul/854bc10eeaf21c9ee2119e0b9f3841a7/scratchpad.ipynb a = tf.keras.layers.ZeroPaddingaD(padding=kernel_size // 2 ) a = tf.keras.layers.ConvaD( filters=__lowerCamelCase ,kernel_size=__lowerCamelCase ,strides=__lowerCamelCase ,padding='''VALID''' ,groups=__lowerCamelCase ,use_bias=__lowerCamelCase ,name='''convolution''' ,) a = tf.keras.layers.BatchNormalization(epsilon=1e-5 ,momentum=0.9 ,name='''normalization''' ) a = ACTaFN[activation] if activation is not None else tf.identity def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : List[str] ): '''simple docstring''' a = self.convolution(self.padding(__lowerCamelCase ) ) a = self.normalization(__lowerCamelCase ) a = self.activation(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Any ,__lowerCamelCase : RegNetConfig ,**__lowerCamelCase : List[Any] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = config.num_channels a = TFRegNetConvLayer( out_channels=config.embedding_size ,kernel_size=3 ,stride=2 ,activation=config.hidden_act ,name='''embedder''' ,) def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : Optional[Any] ): '''simple docstring''' a = shape_list(__lowerCamelCase )[1] if tf.executing_eagerly() and 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.''' ) # When running on CPU, `tf.keras.layers.Conv2D` doesn't support `NCHW` format. # So change the input format from `NCHW` to `NHWC`. # shape = (batch_size, in_height, in_width, in_channels=num_channels) a = tf.transpose(__lowerCamelCase ,perm=(0, 2, 3, 1) ) a = self.embedder(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : str ,__lowerCamelCase : int ,__lowerCamelCase : int = 2 ,**__lowerCamelCase : Tuple ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = tf.keras.layers.ConvaD( filters=__lowerCamelCase ,kernel_size=1 ,strides=__lowerCamelCase ,use_bias=__lowerCamelCase ,name='''convolution''' ) a = tf.keras.layers.BatchNormalization(epsilon=1e-5 ,momentum=0.9 ,name='''normalization''' ) def SCREAMING_SNAKE_CASE_ ( self : Dict ,__lowerCamelCase : tf.Tensor ,__lowerCamelCase : bool = False ): '''simple docstring''' return self.normalization(self.convolution(__lowerCamelCase ) ,training=__lowerCamelCase ) class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : List[Any] ,__lowerCamelCase : int ,__lowerCamelCase : int ,**__lowerCamelCase : str ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = tf.keras.layers.GlobalAveragePoolingaD(keepdims=__lowerCamelCase ,name='''pooler''' ) a = [ tf.keras.layers.ConvaD(filters=__lowerCamelCase ,kernel_size=1 ,activation='''relu''' ,name='''attention.0''' ), tf.keras.layers.ConvaD(filters=__lowerCamelCase ,kernel_size=1 ,activation='''sigmoid''' ,name='''attention.2''' ), ] def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : Optional[Any] ): '''simple docstring''' a = self.pooler(__lowerCamelCase ) for layer_module in self.attention: a = layer_module(__lowerCamelCase ) a = hidden_state * pooled return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Union[str, Any] ,__lowerCamelCase : RegNetConfig ,__lowerCamelCase : int ,__lowerCamelCase : int ,__lowerCamelCase : int = 1 ,**__lowerCamelCase : Dict ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = in_channels != out_channels or stride != 1 a = max(1 ,out_channels // config.groups_width ) a = ( TFRegNetShortCut(__lowerCamelCase ,stride=__lowerCamelCase ,name='''shortcut''' ) if should_apply_shortcut else tf.keras.layers.Activation('''linear''' ,name='''shortcut''' ) ) # `self.layers` instead of `self.layer` because that is a reserved argument. a = [ TFRegNetConvLayer(__lowerCamelCase ,kernel_size=1 ,activation=config.hidden_act ,name='''layer.0''' ), TFRegNetConvLayer( __lowerCamelCase ,stride=__lowerCamelCase ,groups=__lowerCamelCase ,activation=config.hidden_act ,name='''layer.1''' ), TFRegNetConvLayer(__lowerCamelCase ,kernel_size=1 ,activation=__lowerCamelCase ,name='''layer.2''' ), ] a = ACTaFN[config.hidden_act] def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = hidden_state for layer_module in self.layers: a = layer_module(__lowerCamelCase ) a = self.shortcut(__lowerCamelCase ) hidden_state += residual a = self.activation(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Dict ,__lowerCamelCase : RegNetConfig ,__lowerCamelCase : int ,__lowerCamelCase : int ,__lowerCamelCase : int = 1 ,**__lowerCamelCase : List[str] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = in_channels != out_channels or stride != 1 a = max(1 ,out_channels // config.groups_width ) a = ( TFRegNetShortCut(__lowerCamelCase ,stride=__lowerCamelCase ,name='''shortcut''' ) if should_apply_shortcut else tf.keras.layers.Activation('''linear''' ,name='''shortcut''' ) ) a = [ TFRegNetConvLayer(__lowerCamelCase ,kernel_size=1 ,activation=config.hidden_act ,name='''layer.0''' ), TFRegNetConvLayer( __lowerCamelCase ,stride=__lowerCamelCase ,groups=__lowerCamelCase ,activation=config.hidden_act ,name='''layer.1''' ), TFRegNetSELayer(__lowerCamelCase ,reduced_channels=int(round(in_channels / 4 ) ) ,name='''layer.2''' ), TFRegNetConvLayer(__lowerCamelCase ,kernel_size=1 ,activation=__lowerCamelCase ,name='''layer.3''' ), ] a = ACTaFN[config.hidden_act] def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ,__lowerCamelCase : str ): '''simple docstring''' a = hidden_state for layer_module in self.layers: a = layer_module(__lowerCamelCase ) a = self.shortcut(__lowerCamelCase ) hidden_state += residual a = self.activation(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Optional[int] ,__lowerCamelCase : RegNetConfig ,__lowerCamelCase : int ,__lowerCamelCase : int ,__lowerCamelCase : int = 2 ,__lowerCamelCase : int = 2 ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = TFRegNetXLayer if config.layer_type == '''x''' else TFRegNetYLayer a = [ # downsampling is done in the first layer with stride of 2 layer(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ,stride=__lowerCamelCase ,name='''layers.0''' ), *[layer(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ,name=F"""layers.{i+1}""" ) for i in range(depth - 1 )], ] def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : int ): '''simple docstring''' for layer_module in self.layers: a = layer_module(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Union[str, Any] ,__lowerCamelCase : RegNetConfig ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = [] # based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input self.stages.append( TFRegNetStage( __lowerCamelCase ,config.embedding_size ,config.hidden_sizes[0] ,stride=2 if config.downsample_in_first_stage else 1 ,depth=config.depths[0] ,name='''stages.0''' ,) ) a = zip(config.hidden_sizes ,config.hidden_sizes[1:] ) for i, ((in_channels, out_channels), depth) in enumerate(zip(__lowerCamelCase ,config.depths[1:] ) ): self.stages.append(TFRegNetStage(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ,depth=__lowerCamelCase ,name=F"""stages.{i+1}""" ) ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : tf.Tensor ,__lowerCamelCase : bool = False ,__lowerCamelCase : bool = True ): '''simple docstring''' 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(__lowerCamelCase ) 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 TFBaseModelOutputWithNoAttention(last_hidden_state=__lowerCamelCase ,hidden_states=__lowerCamelCase ) @keras_serializable class lowerCamelCase_ ( tf.keras.layers.Layer ): SCREAMING_SNAKE_CASE_ = RegNetConfig def __init__( self : Dict ,__lowerCamelCase : Optional[int] ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = config a = TFRegNetEmbeddings(__lowerCamelCase ,name='''embedder''' ) a = TFRegNetEncoder(__lowerCamelCase ,name='''encoder''' ) a = tf.keras.layers.GlobalAveragePoolingaD(keepdims=__lowerCamelCase ,name='''pooler''' ) @unpack_inputs def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : tf.Tensor ,__lowerCamelCase : Optional[bool] = None ,__lowerCamelCase : Optional[bool] = None ,__lowerCamelCase : bool = False ,): '''simple docstring''' a = ( output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states ) a = return_dict if return_dict is not None else self.config.use_return_dict a = self.embedder(__lowerCamelCase ,training=__lowerCamelCase ) a = self.encoder( __lowerCamelCase ,output_hidden_states=__lowerCamelCase ,return_dict=__lowerCamelCase ,training=__lowerCamelCase ) a = encoder_outputs[0] a = self.pooler(__lowerCamelCase ) # Change to NCHW output format have uniformity in the modules a = tf.transpose(__lowerCamelCase ,perm=(0, 3, 1, 2) ) a = tf.transpose(__lowerCamelCase ,perm=(0, 3, 1, 2) ) # Change the other hidden state outputs to NCHW as well if output_hidden_states: a = tuple([tf.transpose(__lowerCamelCase ,perm=(0, 3, 1, 2) ) for h in encoder_outputs[1]] ) if not return_dict: return (last_hidden_state, pooled_output) + encoder_outputs[1:] return TFBaseModelOutputWithPoolingAndNoAttention( last_hidden_state=__lowerCamelCase ,pooler_output=__lowerCamelCase ,hidden_states=hidden_states if output_hidden_states else encoder_outputs.hidden_states ,) class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = RegNetConfig SCREAMING_SNAKE_CASE_ = 'regnet' SCREAMING_SNAKE_CASE_ = 'pixel_values' @property def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 2_24, 2_24) ,dtype=tf.floataa )} UpperCamelCase__ : Union[str, Any] = R""" Parameters: This model is a Tensorflow [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a regular Tensorflow Module and refer to the Tensorflow documentation for all matter related to general usage and behavior. config ([`RegNetConfig`]): 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 [`~TFPreTrainedModel.from_pretrained`] method to load the model weights. """ UpperCamelCase__ : List[str] = R""" Args: pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`): Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See [`ConveNextImageProcessor.__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 RegNet model outputting raw features without any specific head on top.' , a_ , ) class lowerCamelCase_ ( a_ ): def __init__( self : Optional[int] ,__lowerCamelCase : RegNetConfig ,*__lowerCamelCase : int ,**__lowerCamelCase : Union[str, Any] ): '''simple docstring''' super().__init__(__lowerCamelCase ,*__lowerCamelCase ,**__lowerCamelCase ) a = TFRegNetMainLayer(__lowerCamelCase ,name='''regnet''' ) @unpack_inputs @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 SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : tf.Tensor ,__lowerCamelCase : Optional[bool] = None ,__lowerCamelCase : Optional[bool] = None ,__lowerCamelCase : List[str]=False ,): '''simple docstring''' a = ( output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states ) a = return_dict if return_dict is not None else self.config.use_return_dict a = self.regnet( pixel_values=__lowerCamelCase ,output_hidden_states=__lowerCamelCase ,return_dict=__lowerCamelCase ,training=__lowerCamelCase ,) if not return_dict: return (outputs[0],) + outputs[1:] return TFBaseModelOutputWithPoolingAndNoAttention( last_hidden_state=outputs.last_hidden_state ,pooler_output=outputs.pooler_output ,hidden_states=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 ' , a_ , ) class lowerCamelCase_ ( a_ , a_ ): def __init__( self : Optional[int] ,__lowerCamelCase : RegNetConfig ,*__lowerCamelCase : str ,**__lowerCamelCase : Any ): '''simple docstring''' super().__init__(__lowerCamelCase ,*__lowerCamelCase ,**__lowerCamelCase ) a = config.num_labels a = TFRegNetMainLayer(__lowerCamelCase ,name='''regnet''' ) # classification head a = [ tf.keras.layers.Flatten(), tf.keras.layers.Dense(config.num_labels ,name='''classifier.1''' ) if config.num_labels > 0 else tf.identity, ] @unpack_inputs @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 SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : tf.Tensor = None ,__lowerCamelCase : tf.Tensor = None ,__lowerCamelCase : bool = None ,__lowerCamelCase : bool = None ,__lowerCamelCase : Dict=False ,): '''simple docstring''' a = ( output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states ) a = return_dict if return_dict is not None else self.config.use_return_dict a = self.regnet( __lowerCamelCase ,output_hidden_states=__lowerCamelCase ,return_dict=__lowerCamelCase ,training=__lowerCamelCase ) a = outputs.pooler_output if return_dict else outputs[1] a = self.classifier[0](__lowerCamelCase ) a = self.classifier[1](__lowerCamelCase ) a = None if labels is None else self.hf_compute_loss(labels=__lowerCamelCase ,logits=__lowerCamelCase ) if not return_dict: a = (logits,) + outputs[2:] return ((loss,) + output) if loss is not None else output return TFSequenceClassifierOutput(loss=__lowerCamelCase ,logits=__lowerCamelCase ,hidden_states=outputs.hidden_states )
330
0
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 _A : Any = logging.get_logger(__name__) _A : str = {"vocab_file": "spiece.model"} _A : Tuple = { "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", } } _A : Optional[int] = { "albert-base-v1": 512, "albert-large-v1": 512, "albert-xlarge-v1": 512, "albert-xxlarge-v1": 512, "albert-base-v2": 512, "albert-large-v2": 512, "albert-xlarge-v2": 512, "albert-xxlarge-v2": 512, } _A : Dict = "▁" class lowerCamelCase_ ( 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 : Union[str, Any] ,__lowerCamelCase : str ,__lowerCamelCase : List[str]=True ,__lowerCamelCase : str=True ,__lowerCamelCase : str=False ,__lowerCamelCase : str="[CLS]" ,__lowerCamelCase : Dict="[SEP]" ,__lowerCamelCase : Any="<unk>" ,__lowerCamelCase : str="[SEP]" ,__lowerCamelCase : int="<pad>" ,__lowerCamelCase : Optional[Any]="[CLS]" ,__lowerCamelCase : str="[MASK]" ,__lowerCamelCase : Optional[Dict[str, Any]] = None ,**__lowerCamelCase : str ,): '''simple docstring''' a = ( AddedToken(UpperCAmelCase_ ,lstrip=UpperCAmelCase_ ,rstrip=UpperCAmelCase_ ,normalized=UpperCAmelCase_ ) if isinstance(UpperCAmelCase_ ,UpperCAmelCase_ ) else mask_token ) a = {} if sp_model_kwargs is None else sp_model_kwargs super().__init__( do_lower_case=UpperCAmelCase_ ,remove_space=UpperCAmelCase_ ,keep_accents=UpperCAmelCase_ ,bos_token=UpperCAmelCase_ ,eos_token=UpperCAmelCase_ ,unk_token=UpperCAmelCase_ ,sep_token=UpperCAmelCase_ ,pad_token=UpperCAmelCase_ ,cls_token=UpperCAmelCase_ ,mask_token=UpperCAmelCase_ ,sp_model_kwargs=self.sp_model_kwargs ,**UpperCAmelCase_ ,) a = do_lower_case a = remove_space a = keep_accents a = vocab_file a = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(UpperCAmelCase_ ) @property def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' return len(self.sp_model ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ): '''simple docstring''' a = {self.convert_ids_to_tokens(UpperCAmelCase_ ): i for i in range(self.vocab_size )} vocab.update(self.added_tokens_encoder ) return vocab def __getstate__( self : int ): '''simple docstring''' a = self.__dict__.copy() a = None return state def __setstate__( self : str ,__lowerCamelCase : List[str] ): '''simple docstring''' a = d # for backward compatibility if not hasattr(self ,'''sp_model_kwargs''' ): a = {} a = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(self.vocab_file ) def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : Any ): '''simple docstring''' if self.remove_space: a = " ".join(inputs.strip().split() ) else: a = inputs a = outputs.replace('''``''' ,'''\"''' ).replace('''\'\'''' ,'''\"''' ) if not self.keep_accents: a = unicodedata.normalize('''NFKD''' ,UpperCAmelCase_ ) a = "".join([c for c in outputs if not unicodedata.combining(UpperCAmelCase_ )] ) if self.do_lower_case: a = outputs.lower() return outputs def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : str ): '''simple docstring''' a = self.preprocess_text(UpperCAmelCase_ ) a = self.sp_model.encode(UpperCAmelCase_ ,out_type=UpperCAmelCase_ ) a = [] for piece in pieces: if len(UpperCAmelCase_ ) > 1 and piece[-1] == str(''',''' ) and piece[-2].isdigit(): a = self.sp_model.EncodeAsPieces(piece[:-1].replace(UpperCAmelCase_ ,'''''' ) ) if piece[0] != SPIECE_UNDERLINE and cur_pieces[0][0] == SPIECE_UNDERLINE: if len(cur_pieces[0] ) == 1: a = cur_pieces[1:] else: a = cur_pieces[0][1:] cur_pieces.append(piece[-1] ) new_pieces.extend(UpperCAmelCase_ ) else: new_pieces.append(UpperCAmelCase_ ) return new_pieces def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : int ): '''simple docstring''' return self.sp_model.PieceToId(UpperCAmelCase_ ) def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : int ): '''simple docstring''' return self.sp_model.IdToPiece(UpperCAmelCase_ ) def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : Dict ): '''simple docstring''' a = [] a = "" a = 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(UpperCAmelCase_ ) + token a = True a = [] else: current_sub_tokens.append(UpperCAmelCase_ ) a = False out_string += self.sp_model.decode(UpperCAmelCase_ ) return out_string.strip() def SCREAMING_SNAKE_CASE_ ( self : List[Any] ,__lowerCamelCase : List[int] ,__lowerCamelCase : Optional[List[int]] = None ): '''simple docstring''' a = [self.sep_token_id] a = [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 : Optional[int] ,__lowerCamelCase : List[int] ,__lowerCamelCase : Optional[List[int]] = None ,__lowerCamelCase : bool = False ): '''simple docstring''' if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=UpperCAmelCase_ ,token_ids_a=UpperCAmelCase_ ,already_has_special_tokens=UpperCAmelCase_ ) if token_ids_a is not None: return [1] + ([0] * len(UpperCAmelCase_ )) + [1] + ([0] * len(UpperCAmelCase_ )) + [1] return [1] + ([0] * len(UpperCAmelCase_ )) + [1] def SCREAMING_SNAKE_CASE_ ( self : Dict ,__lowerCamelCase : List[int] ,__lowerCamelCase : Optional[List[int]] = None ): '''simple docstring''' a = [self.sep_token_id] a = [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 : Tuple ,__lowerCamelCase : str ,__lowerCamelCase : Optional[str] = None ): '''simple docstring''' if not os.path.isdir(UpperCAmelCase_ ): logger.error(F"""Vocabulary path ({save_directory}) should be a directory""" ) return a = os.path.join( UpperCAmelCase_ ,(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file'''] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(UpperCAmelCase_ ) and os.path.isfile(self.vocab_file ): copyfile(self.vocab_file ,UpperCAmelCase_ ) elif not os.path.isfile(self.vocab_file ): with open(UpperCAmelCase_ ,'''wb''' ) as fi: a = self.sp_model.serialized_model_proto() fi.write(UpperCAmelCase_ ) return (out_vocab_file,)
365
from typing import List from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCamelCase__ : Union[str, Any] = logging.get_logger(__name__) UpperCamelCase__ : List[str] = { """snap-research/efficientformer-l1-300""": ( """https://huggingface.co/snap-research/efficientformer-l1-300/resolve/main/config.json""" ), } class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = 'efficientformer' def __init__( self : Optional[int] ,__lowerCamelCase : List[int] = [3, 2, 6, 4] ,__lowerCamelCase : List[int] = [48, 96, 2_24, 4_48] ,__lowerCamelCase : List[bool] = [True, True, True, True] ,__lowerCamelCase : int = 4_48 ,__lowerCamelCase : int = 32 ,__lowerCamelCase : int = 4 ,__lowerCamelCase : int = 7 ,__lowerCamelCase : int = 5 ,__lowerCamelCase : int = 8 ,__lowerCamelCase : int = 4 ,__lowerCamelCase : float = 0.0 ,__lowerCamelCase : int = 16 ,__lowerCamelCase : int = 3 ,__lowerCamelCase : int = 3 ,__lowerCamelCase : int = 3 ,__lowerCamelCase : int = 2 ,__lowerCamelCase : int = 1 ,__lowerCamelCase : float = 0.0 ,__lowerCamelCase : int = 1 ,__lowerCamelCase : bool = True ,__lowerCamelCase : bool = True ,__lowerCamelCase : float = 1e-5 ,__lowerCamelCase : str = "gelu" ,__lowerCamelCase : float = 0.02 ,__lowerCamelCase : float = 1e-12 ,__lowerCamelCase : int = 2_24 ,__lowerCamelCase : float = 1e-05 ,**__lowerCamelCase : Dict ,): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = hidden_act a = hidden_dropout_prob a = hidden_sizes a = num_hidden_layers a = num_attention_heads a = initializer_range a = layer_norm_eps a = patch_size a = num_channels a = depths a = mlp_expansion_ratio a = downsamples a = dim a = key_dim a = attention_ratio a = resolution a = pool_size a = downsample_patch_size a = downsample_stride a = downsample_pad a = drop_path_rate a = num_metaad_blocks a = distillation a = use_layer_scale a = layer_scale_init_value a = image_size a = batch_norm_eps
330
0
def SCREAMING_SNAKE_CASE__ ( snake_case_ = 1_0_0_0 ) -> int: """simple docstring""" return sum(e for e in range(3, SCREAMING_SNAKE_CASE_ ) if e % 3 == 0 or e % 5 == 0 ) if __name__ == "__main__": print(F"{solution() = }")
366
import argparse from typing import Dict import tensorflow as tf import torch from tqdm import tqdm from transformers import BigBirdPegasusConfig, BigBirdPegasusForConditionalGeneration UpperCamelCase__ : Any = [ # tf -> hf ("""/""", """."""), ("""layer_""", """layers."""), ("""kernel""", """weight"""), ("""beta""", """bias"""), ("""gamma""", """weight"""), ("""pegasus""", """model"""), ] UpperCamelCase__ : Optional[Any] = [ (""".output.dense""", """.fc2"""), ("""intermediate.LayerNorm""", """final_layer_norm"""), ("""intermediate.dense""", """fc1"""), ] UpperCamelCase__ : Optional[Any] = ( INIT_COMMON + [ ("""attention.self.LayerNorm""", """self_attn_layer_norm"""), ("""attention.output.dense""", """self_attn.out_proj"""), ("""attention.self""", """self_attn"""), ("""attention.encdec.LayerNorm""", """encoder_attn_layer_norm"""), ("""attention.encdec_output.dense""", """encoder_attn.out_proj"""), ("""attention.encdec""", """encoder_attn"""), ("""key""", """k_proj"""), ("""value""", """v_proj"""), ("""query""", """q_proj"""), ("""decoder.LayerNorm""", """decoder.layernorm_embedding"""), ] + END_COMMON ) UpperCamelCase__ : List[str] = ( INIT_COMMON + [ ("""embeddings.word_embeddings""", """shared.weight"""), ("""embeddings.position_embeddings""", """embed_positions.weight"""), ("""attention.self.LayerNorm""", """self_attn_layer_norm"""), ("""attention.output.dense""", """self_attn.output"""), ("""attention.self""", """self_attn.self"""), ("""encoder.LayerNorm""", """encoder.layernorm_embedding"""), ] + END_COMMON ) UpperCamelCase__ : Optional[int] = [ """encdec/key/bias""", """encdec/query/bias""", """encdec/value/bias""", """self/key/bias""", """self/query/bias""", """self/value/bias""", """encdec_output/dense/bias""", """attention/output/dense/bias""", ] def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> List[Any]: """simple docstring""" for tf_name, hf_name in patterns: a = k.replace(snake_case_, snake_case_ ) return k def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> BigBirdPegasusForConditionalGeneration: """simple docstring""" a = BigBirdPegasusConfig(**snake_case_ ) a = BigBirdPegasusForConditionalGeneration(snake_case_ ) a = torch_model.state_dict() a = {} # separating decoder weights a = {k: tf_weights[k] for k in tf_weights if k.startswith('''pegasus/decoder''' )} a = {k: tf_weights[k] for k in tf_weights if not k.startswith('''pegasus/decoder''' )} for k, v in tqdm(decoder_weights.items(), '''tf -> hf conversion''' ): a = [k.endswith(snake_case_ ) for ending in KEYS_TO_IGNORE] if any(snake_case_ ): continue a = DECODER_PATTERNS a = rename_state_dict_key(snake_case_, snake_case_ ) if new_k not in state_dict: raise ValueError(f"""could not find new key {new_k} in state dict. (converted from {k})""" ) if any(True if i in k else False for i in ['''dense''', '''query''', '''key''', '''value'''] ): a = v.T a = torch.from_numpy(snake_case_ ) assert v.shape == state_dict[new_k].shape, f"""{new_k}, {k}, {v.shape}, {state_dict[new_k].shape}""" for k, v in tqdm(remaining_weights.items(), '''tf -> hf conversion''' ): a = [k.endswith(snake_case_ ) for ending in KEYS_TO_IGNORE] if any(snake_case_ ): continue a = REMAINING_PATTERNS a = rename_state_dict_key(snake_case_, snake_case_ ) if new_k not in state_dict and k != "pegasus/embeddings/position_embeddings": raise ValueError(f"""could not find new key {new_k} in state dict. (converted from {k})""" ) if any(True if i in k else False for i in ['''dense''', '''query''', '''key''', '''value'''] ): a = v.T a = torch.from_numpy(snake_case_ ) if k != "pegasus/embeddings/position_embeddings": assert v.shape == state_dict[new_k].shape, f"""{new_k}, {k}, {v.shape}, {state_dict[new_k].shape}""" a = mapping['''model.embed_positions.weight'''] a = mapping.pop('''model.embed_positions.weight''' ) a , a = torch_model.load_state_dict(snake_case_, strict=snake_case_ ) a = [ k for k in missing if k not in [ '''final_logits_bias''', '''model.encoder.embed_tokens.weight''', '''model.decoder.embed_tokens.weight''', '''lm_head.weight''', ] ] assert unexpected_missing == [], f"""no matches found for the following torch keys {unexpected_missing}""" assert extra == [], f"""no matches found for the following tf keys {extra}""" return torch_model def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Dict: """simple docstring""" a = tf.train.list_variables(snake_case_ ) a = {} a = ['''global_step'''] for name, shape in tqdm(snake_case_, desc='''converting tf checkpoint to dict''' ): a = any(pat in name for pat in ignore_name ) if skip_key: continue a = tf.train.load_variable(snake_case_, snake_case_ ) a = array return tf_weights def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> int: """simple docstring""" a = get_tf_weights_as_numpy(snake_case_ ) a = convert_bigbird_pegasus(snake_case_, snake_case_ ) torch_model.save_pretrained(snake_case_ ) if __name__ == "__main__": UpperCamelCase__ : str = argparse.ArgumentParser() parser.add_argument("""--tf_ckpt_path""", type=str, help="""passed to tf.train.list_variables""") parser.add_argument("""--save_dir""", default=None, type=str, help="""Path to the output PyTorch model.""") UpperCamelCase__ : int = parser.parse_args() UpperCamelCase__ : Tuple = {} convert_bigbird_pegasus_ckpt_to_pytorch(args.tf_ckpt_path, args.save_dir, config_update=config_update)
330
0
import os # All paths are set with the intent you should run this script from the root of the repo with the command # python utils/check_doctest_list.py UpperCamelCase__ : str = '.' if __name__ == "__main__": UpperCamelCase__ : List[str] = os.path.join(REPO_PATH, """utils/documentation_tests.txt""") UpperCamelCase__ : List[str] = [] UpperCamelCase__ : List[Any] = [] with open(doctest_file_path) as fp: for line in fp: UpperCamelCase__ : Tuple = line.strip() UpperCamelCase__ : Optional[int] = os.path.join(REPO_PATH, line) if not (os.path.isfile(path) or os.path.isdir(path)): non_existent_paths.append(line) all_paths.append(path) if len(non_existent_paths) > 0: UpperCamelCase__ : Union[str, Any] = '\n'.join(non_existent_paths) raise ValueError(F"`utils/documentation_tests.txt` contains non-existent paths:\n{non_existent_paths}") if all_paths != sorted(all_paths): raise ValueError("""Files in `utils/documentation_tests.txt` are not in alphabetical order.""")
367
import re def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> str: """simple docstring""" if len(re.findall('''[ATCG]''', snake_case_ ) ) != len(snake_case_ ): raise ValueError('''Invalid Strand''' ) return dna.translate(dna.maketrans('''ATCG''', '''TAGC''' ) ) if __name__ == "__main__": import doctest doctest.testmod()
330
0
"""simple docstring""" from bisect import bisect from itertools import accumulate def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_ ) -> str: """simple docstring""" a = sorted(zip(__lowerCamelCase, __lowerCamelCase ), key=lambda snake_case_ : x[0] / x[1], reverse=__lowerCamelCase ) a , a = [i[0] for i in r], [i[1] for i in r] a = list(accumulate(__lowerCamelCase ) ) a = bisect(__lowerCamelCase, __lowerCamelCase ) return ( 0 if k == 0 else sum(vl[:k] ) + (w - acc[k - 1]) * (vl[k]) / (wt[k]) if k != n else sum(vl[:k] ) ) if __name__ == "__main__": import doctest doctest.testmod()
368
from __future__ import annotations from collections.abc import Sequence from typing import Literal def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> str | Literal[False]: """simple docstring""" a = list(snake_case_ ) a = list(snake_case_ ) a = 0 for i in range(len(snake_case_ ) ): if lista[i] != lista[i]: count += 1 a = '''_''' if count > 1: return False else: return "".join(snake_case_ ) def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> list[str]: """simple docstring""" a = [] while True: a = ['''$'''] * len(snake_case_ ) a = [] for i in range(len(snake_case_ ) ): for j in range(i + 1, len(snake_case_ ) ): a = compare_string(binary[i], binary[j] ) if k is False: a = '''*''' a = '''*''' temp.append('''X''' ) for i in range(len(snake_case_ ) ): if checka[i] == "$": pi.append(binary[i] ) if len(snake_case_ ) == 0: return pi a = list(set(snake_case_ ) ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> list[str]: """simple docstring""" a = [] for minterm in minterms: a = '''''' for _ in range(snake_case_ ): a = str(minterm % 2 ) + string minterm //= 2 temp.append(snake_case_ ) return temp def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> bool: """simple docstring""" a = list(snake_case_ ) a = list(snake_case_ ) a = 0 for i in range(len(snake_case_ ) ): if lista[i] != lista[i]: count_n += 1 return count_n == count def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> list[str]: """simple docstring""" a = [] a = [0] * len(snake_case_ ) for i in range(len(chart[0] ) ): a = 0 a = -1 for j in range(len(snake_case_ ) ): if chart[j][i] == 1: count += 1 a = j if count == 1: a = 1 for i in range(len(snake_case_ ) ): if select[i] == 1: for j in range(len(chart[0] ) ): if chart[i][j] == 1: for k in range(len(snake_case_ ) ): a = 0 temp.append(prime_implicants[i] ) while True: a = 0 a = -1 a = 0 for i in range(len(snake_case_ ) ): a = chart[i].count(1 ) if count_n > max_n: a = count_n a = i if max_n == 0: return temp temp.append(prime_implicants[rem] ) for i in range(len(chart[0] ) ): if chart[rem][i] == 1: for j in range(len(snake_case_ ) ): a = 0 def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> list[list[int]]: """simple docstring""" a = [[0 for x in range(len(snake_case_ ) )] for x in range(len(snake_case_ ) )] for i in range(len(snake_case_ ) ): a = prime_implicants[i].count('''_''' ) for j in range(len(snake_case_ ) ): if is_for_table(prime_implicants[i], binary[j], snake_case_ ): a = 1 return chart def SCREAMING_SNAKE_CASE__ ( ) -> None: """simple docstring""" a = int(input('''Enter the no. of variables\n''' ) ) a = [ float(snake_case_ ) for x in input( '''Enter the decimal representation of Minterms \'Spaces Separated\'\n''' ).split() ] a = decimal_to_binary(snake_case_, snake_case_ ) a = check(snake_case_ ) print('''Prime Implicants are:''' ) print(snake_case_ ) a = prime_implicant_chart(snake_case_, snake_case_ ) a = selection(snake_case_, snake_case_ ) print('''Essential Prime Implicants are:''' ) print(snake_case_ ) if __name__ == "__main__": import doctest doctest.testmod() main()
330
0
from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCamelCase__ : Any = logging.get_logger(__name__) UpperCamelCase__ : Tuple = { "google/pegasus-large": "https://huggingface.co/google/pegasus-large/resolve/main/config.json", # See all PEGASUS models at https://huggingface.co/models?filter=pegasus } class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = 'pegasus' SCREAMING_SNAKE_CASE_ = ['past_key_values'] SCREAMING_SNAKE_CASE_ = {'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'} def __init__( self : Tuple ,__lowerCamelCase : Optional[int]=5_02_65 ,__lowerCamelCase : str=10_24 ,__lowerCamelCase : List[str]=12 ,__lowerCamelCase : Any=40_96 ,__lowerCamelCase : int=16 ,__lowerCamelCase : List[Any]=12 ,__lowerCamelCase : Union[str, Any]=40_96 ,__lowerCamelCase : str=16 ,__lowerCamelCase : int=0.0 ,__lowerCamelCase : Any=0.0 ,__lowerCamelCase : List[str]=True ,__lowerCamelCase : Union[str, Any]=True ,__lowerCamelCase : Any="gelu" ,__lowerCamelCase : List[str]=10_24 ,__lowerCamelCase : Any=0.1 ,__lowerCamelCase : str=0.0 ,__lowerCamelCase : Optional[Any]=0.0 ,__lowerCamelCase : Optional[int]=0.02 ,__lowerCamelCase : Tuple=0 ,__lowerCamelCase : Optional[int]=False ,__lowerCamelCase : Union[str, Any]=0 ,__lowerCamelCase : Optional[Any]=1 ,__lowerCamelCase : List[str]=1 ,**__lowerCamelCase : Tuple ,): '''simple docstring''' a = vocab_size a = max_position_embeddings a = d_model a = encoder_ffn_dim a = encoder_layers a = encoder_attention_heads a = decoder_ffn_dim a = decoder_layers a = decoder_attention_heads a = dropout a = attention_dropout a = activation_dropout a = activation_function a = init_std a = encoder_layerdrop a = decoder_layerdrop a = use_cache a = encoder_layers a = scale_embedding # scale factor will be sqrt(d_model) if True super().__init__( pad_token_id=_a ,eos_token_id=_a ,is_encoder_decoder=_a ,decoder_start_token_id=_a ,forced_eos_token_id=_a ,**_a ,) @property def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' return self.encoder_attention_heads @property def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' return self.d_model
369
from typing import List, Union import numpy as np from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_torch_available(): import torch from ..models.auto.modeling_auto import MODEL_FOR_DEPTH_ESTIMATION_MAPPING UpperCamelCase__ : List[str] = logging.get_logger(__name__) @add_end_docstrings(a_ ) class lowerCamelCase_ ( a_ ): def __init__( self : int ,*__lowerCamelCase : str ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' super().__init__(*__lowerCamelCase ,**__lowerCamelCase ) requires_backends(self ,'''vision''' ) self.check_model_type(__lowerCamelCase ) def __call__( self : int ,__lowerCamelCase : Union[str, List[str], "Image.Image", List["Image.Image"]] ,**__lowerCamelCase : str ): '''simple docstring''' return super().__call__(__lowerCamelCase ,**__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Any ,**__lowerCamelCase : Dict ): '''simple docstring''' return {}, {}, {} def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = load_image(__lowerCamelCase ) a = image.size a = self.image_processor(images=__lowerCamelCase ,return_tensors=self.framework ) return model_inputs def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = self.model(**__lowerCamelCase ) return model_outputs def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = model_outputs.predicted_depth a = torch.nn.functional.interpolate( predicted_depth.unsqueeze(1 ) ,size=self.image_size[::-1] ,mode='''bicubic''' ,align_corners=__lowerCamelCase ) a = prediction.squeeze().cpu().numpy() a = (output * 2_55 / np.max(__lowerCamelCase )).astype('''uint8''' ) a = Image.fromarray(__lowerCamelCase ) a = {} a = predicted_depth a = depth return output_dict
330
0
import pytest from datasets import inspect_metric, list_metrics, load_metric @pytest.fixture def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Dict: """simple docstring""" monkeypatch.setattr('''datasets.utils.deprecation_utils._emitted_deprecation_warnings''', set() ) @pytest.fixture def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> str: """simple docstring""" class lowerCamelCase_ : def __init__( self : str ,__lowerCamelCase : Any ): '''simple docstring''' a = metric_id class lowerCamelCase_ : SCREAMING_SNAKE_CASE_ = [MetricMock(_a ) for metric_id in ['accuracy', 'mse', 'precision', 'codeparrot/apps_metric']] def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ): '''simple docstring''' return self._metrics monkeypatch.setattr('''datasets.inspect.huggingface_hub''', HfhMock() ) @pytest.mark.parametrize( '''func, args''', [(load_metric, ('''metrics/mse''',)), (list_metrics, ()), (inspect_metric, ('''metrics/mse''', '''tmp_path'''))] ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) -> str: """simple docstring""" if "tmp_path" in args: a = tuple(arg if arg != '''tmp_path''' else tmp_path for arg in args ) with pytest.warns(snake_case_, match='''https://huggingface.co/docs/evaluate''' ): func(*snake_case_ )
370
from dataclasses import dataclass, field from typing import ClassVar, Dict from ..features import Features, Value from .base import TaskTemplate @dataclass(frozen=a_ ) class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = field(default='language-modeling' , metadata={'include_in_asdict_even_if_is_default': True} ) SCREAMING_SNAKE_CASE_ = Features({'text': Value('string' )} ) SCREAMING_SNAKE_CASE_ = Features({} ) SCREAMING_SNAKE_CASE_ = "text" @property def SCREAMING_SNAKE_CASE_ ( self : int ): '''simple docstring''' return {self.text_column: "text"}
330
0
import json import os import unittest from transformers.models.ctrl.tokenization_ctrl import VOCAB_FILES_NAMES, CTRLTokenizer from ...test_tokenization_common import TokenizerTesterMixin class lowerCamelCase_ ( _a , unittest.TestCase ): SCREAMING_SNAKE_CASE_ = CTRLTokenizer SCREAMING_SNAKE_CASE_ = False SCREAMING_SNAKE_CASE_ = False def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ): '''simple docstring''' super().setUp() # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt a = ["""adapt""", """re@@""", """a@@""", """apt""", """c@@""", """t""", """<unk>"""] a = dict(zip(snake_case_ ,range(len(snake_case_ ) ) ) ) a = ["""#version: 0.2""", """a p""", """ap t</w>""", """r e""", """a d""", """ad apt</w>""", """"""] a = {"""unk_token""": """<unk>"""} a = os.path.join(self.tmpdirname ,VOCAB_FILES_NAMES['''vocab_file'''] ) a = os.path.join(self.tmpdirname ,VOCAB_FILES_NAMES['''merges_file'''] ) with open(self.vocab_file ,'''w''' ,encoding='''utf-8''' ) as fp: fp.write(json.dumps(snake_case_ ) + '''\n''' ) with open(self.merges_file ,'''w''' ,encoding='''utf-8''' ) as fp: fp.write('''\n'''.join(snake_case_ ) ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,**__lowerCamelCase : List[str] ): '''simple docstring''' kwargs.update(self.special_tokens_map ) return CTRLTokenizer.from_pretrained(self.tmpdirname ,**snake_case_ ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : Optional[int] ): '''simple docstring''' a = """adapt react readapt apt""" a = """adapt react readapt apt""" return input_text, output_text def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ): '''simple docstring''' a = CTRLTokenizer(self.vocab_file ,self.merges_file ,**self.special_tokens_map ) a = """adapt react readapt apt""" a = """adapt re@@ a@@ c@@ t re@@ adapt apt""".split() a = tokenizer.tokenize(snake_case_ ) self.assertListEqual(snake_case_ ,snake_case_ ) a = tokens + [tokenizer.unk_token] a = [0, 1, 2, 4, 5, 1, 0, 3, 6] self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case_ ) ,snake_case_ )
371
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__ : Union[str, Any] = logging.get_logger(__name__) UpperCamelCase__ : Union[str, Any] = { """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_ ): SCREAMING_SNAKE_CASE_ = 'yolos' def __init__( self : Union[str, Any] ,__lowerCamelCase : int=7_68 ,__lowerCamelCase : Dict=12 ,__lowerCamelCase : Union[str, Any]=12 ,__lowerCamelCase : List[Any]=30_72 ,__lowerCamelCase : int="gelu" ,__lowerCamelCase : int=0.0 ,__lowerCamelCase : str=0.0 ,__lowerCamelCase : Optional[Any]=0.02 ,__lowerCamelCase : int=1e-12 ,__lowerCamelCase : Any=[5_12, 8_64] ,__lowerCamelCase : Tuple=16 ,__lowerCamelCase : int=3 ,__lowerCamelCase : Tuple=True ,__lowerCamelCase : Optional[int]=1_00 ,__lowerCamelCase : List[Any]=True ,__lowerCamelCase : List[str]=False ,__lowerCamelCase : int=1 ,__lowerCamelCase : List[Any]=5 ,__lowerCamelCase : Optional[int]=2 ,__lowerCamelCase : int=5 ,__lowerCamelCase : str=2 ,__lowerCamelCase : Tuple=0.1 ,**__lowerCamelCase : List[Any] ,): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = hidden_size a = num_hidden_layers a = num_attention_heads a = intermediate_size a = hidden_act a = hidden_dropout_prob a = attention_probs_dropout_prob a = initializer_range a = layer_norm_eps a = image_size a = patch_size a = num_channels a = qkv_bias a = num_detection_tokens a = use_mid_position_embeddings a = auxiliary_loss # Hungarian matcher a = class_cost a = bbox_cost a = giou_cost # Loss coefficients a = bbox_loss_coefficient a = giou_loss_coefficient a = eos_coefficient class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = version.parse('1.11' ) @property def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' return OrderedDict( [ ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}), ] ) @property def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ): '''simple docstring''' return 1e-4 @property def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' return 12
330
0
import logging import os import random import sys from dataclasses import dataclass, field from typing import Optional import datasets import evaluate import numpy as np from datasets import load_dataset import transformers from transformers import ( AutoConfig, AutoModelForSequenceClassification, AutoTokenizer, DataCollatorWithPadding, EvalPrediction, HfArgumentParser, Trainer, TrainingArguments, default_data_collator, set_seed, ) 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 # 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/text-classification/requirements.txt""") UpperCamelCase__ : Tuple = logging.getLogger(__name__) @dataclass class lowerCamelCase_ : SCREAMING_SNAKE_CASE_ = field( default=1_28 , metadata={ 'help': ( 'The maximum total input sequence length after tokenization. Sequences longer ' 'than this will be truncated, sequences shorter will be padded.' ) } , ) SCREAMING_SNAKE_CASE_ = field( default=__lowerCamelCase , metadata={'help': 'Overwrite the cached preprocessed datasets or not.'} ) SCREAMING_SNAKE_CASE_ = field( default=__lowerCamelCase , 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.' ) } , ) SCREAMING_SNAKE_CASE_ = field( default=__lowerCamelCase , metadata={ 'help': ( 'For debugging purposes or quicker training, truncate the number of training examples to this ' 'value if set.' ) } , ) SCREAMING_SNAKE_CASE_ = field( default=__lowerCamelCase , metadata={ 'help': ( 'For debugging purposes or quicker training, truncate the number of evaluation examples to this ' 'value if set.' ) } , ) SCREAMING_SNAKE_CASE_ = field( default=__lowerCamelCase , metadata={ 'help': ( 'For debugging purposes or quicker training, truncate the number of prediction examples to this ' 'value if set.' ) } , ) @dataclass class lowerCamelCase_ : SCREAMING_SNAKE_CASE_ = field( default=__lowerCamelCase , metadata={'help': 'Path to pretrained model or model identifier from huggingface.co/models'} ) SCREAMING_SNAKE_CASE_ = field( default=__lowerCamelCase , metadata={'help': 'Evaluation language. Also train language if `train_language` is set to None.'} ) SCREAMING_SNAKE_CASE_ = field( default=__lowerCamelCase , metadata={'help': 'Train language if it is different from the evaluation language.'} ) SCREAMING_SNAKE_CASE_ = field( default=__lowerCamelCase , metadata={'help': 'Pretrained config name or path if not the same as model_name'} ) SCREAMING_SNAKE_CASE_ = field( default=__lowerCamelCase , metadata={'help': 'Pretrained tokenizer name or path if not the same as model_name'} ) SCREAMING_SNAKE_CASE_ = field( default=__lowerCamelCase , metadata={'help': 'Where do you want to store the pretrained models downloaded from huggingface.co'} , ) SCREAMING_SNAKE_CASE_ = field( default=__lowerCamelCase , metadata={'help': 'arg to indicate if tokenizer should do lower case in AutoTokenizer.from_pretrained()'} , ) SCREAMING_SNAKE_CASE_ = field( default=__lowerCamelCase , metadata={'help': 'Whether to use one of the fast tokenizer (backed by the tokenizers library) or not.'} , ) SCREAMING_SNAKE_CASE_ = field( default='main' , metadata={'help': 'The specific model version to use (can be a branch name, tag name or commit id).'} , ) SCREAMING_SNAKE_CASE_ = field( default=__lowerCamelCase , metadata={ 'help': ( 'Will use the token generated when running `huggingface-cli login` (necessary to use this script ' 'with private models).' ) } , ) SCREAMING_SNAKE_CASE_ = field( default=__lowerCamelCase , metadata={'help': 'Will enable to load a pretrained model whose head dimensions are different.'} , ) def SCREAMING_SNAKE_CASE__ ( ) -> Tuple: """simple docstring""" a = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments) ) a = 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_xnli''', __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() a = 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. a = None if os.path.isdir(training_args.output_dir ) and training_args.do_train and not training_args.overwrite_output_dir: a = 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: 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 ) # In distributed training, the load_dataset function guarantees that only one local process can concurrently # download the dataset. # Downloading and loading xnli dataset from the hub. if training_args.do_train: if model_args.train_language is None: a = load_dataset( '''xnli''', model_args.language, split='''train''', cache_dir=model_args.cache_dir, use_auth_token=True if model_args.use_auth_token else None, ) else: a = load_dataset( '''xnli''', model_args.train_language, split='''train''', cache_dir=model_args.cache_dir, use_auth_token=True if model_args.use_auth_token else None, ) a = train_dataset.features['''label'''].names if training_args.do_eval: a = load_dataset( '''xnli''', model_args.language, split='''validation''', cache_dir=model_args.cache_dir, use_auth_token=True if model_args.use_auth_token else None, ) a = eval_dataset.features['''label'''].names if training_args.do_predict: a = load_dataset( '''xnli''', model_args.language, split='''test''', cache_dir=model_args.cache_dir, use_auth_token=True if model_args.use_auth_token else None, ) a = predict_dataset.features['''label'''].names # Labels a = len(__lowerCAmelCase ) # Load pretrained model and tokenizer # In distributed training, the .from_pretrained methods guarantee that only one local process can concurrently # download model & vocab. a = AutoConfig.from_pretrained( model_args.config_name if model_args.config_name else model_args.model_name_or_path, num_labels=__lowerCAmelCase, idalabel={str(__lowerCAmelCase ): label for i, label in enumerate(__lowerCAmelCase )}, labelaid={label: i for i, label in enumerate(__lowerCAmelCase )}, finetuning_task='''xnli''', cache_dir=model_args.cache_dir, revision=model_args.model_revision, use_auth_token=True if model_args.use_auth_token else None, ) a = AutoTokenizer.from_pretrained( model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path, do_lower_case=model_args.do_lower_case, 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, ) a = AutoModelForSequenceClassification.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, ignore_mismatched_sizes=model_args.ignore_mismatched_sizes, ) # Preprocessing the datasets # Padding strategy if data_args.pad_to_max_length: a = '''max_length''' else: # We will pad later, dynamically at batch creation, to the max sequence length in each batch a = False def preprocess_function(snake_case_ ): # Tokenize the texts return tokenizer( examples['''premise'''], examples['''hypothesis'''], padding=__lowerCAmelCase, max_length=data_args.max_seq_length, truncation=__lowerCAmelCase, ) if training_args.do_train: if data_args.max_train_samples is not None: a = min(len(__lowerCAmelCase ), data_args.max_train_samples ) a = train_dataset.select(range(__lowerCAmelCase ) ) with training_args.main_process_first(desc='''train dataset map pre-processing''' ): a = train_dataset.map( __lowerCAmelCase, batched=__lowerCAmelCase, load_from_cache_file=not data_args.overwrite_cache, desc='''Running tokenizer on train dataset''', ) # Log a few random samples from the training set: for index in random.sample(range(len(__lowerCAmelCase ) ), 3 ): logger.info(f"""Sample {index} of the training set: {train_dataset[index]}.""" ) if training_args.do_eval: if data_args.max_eval_samples is not None: a = min(len(__lowerCAmelCase ), data_args.max_eval_samples ) a = eval_dataset.select(range(__lowerCAmelCase ) ) with training_args.main_process_first(desc='''validation dataset map pre-processing''' ): a = eval_dataset.map( __lowerCAmelCase, batched=__lowerCAmelCase, load_from_cache_file=not data_args.overwrite_cache, desc='''Running tokenizer on validation dataset''', ) if training_args.do_predict: if data_args.max_predict_samples is not None: a = min(len(__lowerCAmelCase ), data_args.max_predict_samples ) a = predict_dataset.select(range(__lowerCAmelCase ) ) with training_args.main_process_first(desc='''prediction dataset map pre-processing''' ): a = predict_dataset.map( __lowerCAmelCase, batched=__lowerCAmelCase, load_from_cache_file=not data_args.overwrite_cache, desc='''Running tokenizer on prediction dataset''', ) # Get the metric function a = evaluate.load('''xnli''' ) # 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(snake_case_ ): a = p.predictions[0] if isinstance(p.predictions, __lowerCAmelCase ) else p.predictions a = np.argmax(__lowerCAmelCase, axis=1 ) return metric.compute(predictions=__lowerCAmelCase, references=p.label_ids ) # Data collator will default to DataCollatorWithPadding, so we change it if we already did the padding. if data_args.pad_to_max_length: a = default_data_collator elif training_args.fpaa: a = DataCollatorWithPadding(__lowerCAmelCase, pad_to_multiple_of=8 ) else: a = None # Initialize our Trainer a = 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, compute_metrics=__lowerCAmelCase, tokenizer=__lowerCAmelCase, data_collator=__lowerCAmelCase, ) # Training if training_args.do_train: a = None if training_args.resume_from_checkpoint is not None: a = training_args.resume_from_checkpoint elif last_checkpoint is not None: a = last_checkpoint a = trainer.train(resume_from_checkpoint=__lowerCAmelCase ) a = train_result.metrics a = ( data_args.max_train_samples if data_args.max_train_samples is not None else len(__lowerCAmelCase ) ) a = min(__lowerCAmelCase, len(__lowerCAmelCase ) ) trainer.save_model() # Saves the tokenizer too for easy upload trainer.log_metrics('''train''', __lowerCAmelCase ) trainer.save_metrics('''train''', __lowerCAmelCase ) trainer.save_state() # Evaluation if training_args.do_eval: logger.info('''*** Evaluate ***''' ) a = trainer.evaluate(eval_dataset=__lowerCAmelCase ) a = data_args.max_eval_samples if data_args.max_eval_samples is not None else len(__lowerCAmelCase ) a = min(__lowerCAmelCase, len(__lowerCAmelCase ) ) trainer.log_metrics('''eval''', __lowerCAmelCase ) trainer.save_metrics('''eval''', __lowerCAmelCase ) # Prediction if training_args.do_predict: logger.info('''*** Predict ***''' ) a = trainer.predict(__lowerCAmelCase, metric_key_prefix='''predict''' ) a = ( data_args.max_predict_samples if data_args.max_predict_samples is not None else len(__lowerCAmelCase ) ) a = min(__lowerCAmelCase, len(__lowerCAmelCase ) ) trainer.log_metrics('''predict''', __lowerCAmelCase ) trainer.save_metrics('''predict''', __lowerCAmelCase ) a = np.argmax(__lowerCAmelCase, axis=1 ) a = os.path.join(training_args.output_dir, '''predictions.txt''' ) if trainer.is_world_process_zero(): with open(__lowerCAmelCase, '''w''' ) as writer: writer.write('''index\tprediction\n''' ) for index, item in enumerate(__lowerCAmelCase ): a = label_list[item] writer.write(f"""{index}\t{item}\n""" ) if __name__ == "__main__": main()
350
def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> int: """simple docstring""" a = '''''' for i in table: res += inp[i - 1] return res def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> int: """simple docstring""" return data[1:] + data[0] def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> List[str]: """simple docstring""" a = '''''' for i in range(len(snake_case_ ) ): if a[i] == b[i]: res += "0" else: res += "1" return res def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> Dict: """simple docstring""" a = int('''0b''' + data[0] + data[-1], 2 ) a = int('''0b''' + data[1:3], 2 ) return bin(s[row][col] )[2:] def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) -> Optional[int]: """simple docstring""" a = message[:4] a = message[4:] a = apply_table(snake_case_, snake_case_ ) a = xor(snake_case_, snake_case_ ) a = apply_sbox(snake_case_, temp[:4] ) # noqa: E741 a = apply_sbox(snake_case_, temp[4:] ) a = '''0''' * (2 - len(snake_case_ )) + l # noqa: E741 a = '''0''' * (2 - len(snake_case_ )) + r a = apply_table(l + r, snake_case_ ) a = xor(snake_case_, snake_case_ ) return temp + right if __name__ == "__main__": UpperCamelCase__ : int = input("""Enter 10 bit key: """) UpperCamelCase__ : Union[str, Any] = input("""Enter 8 bit message: """) UpperCamelCase__ : Dict = [6, 3, 7, 4, 8, 5, 10, 9] UpperCamelCase__ : Union[str, Any] = [3, 5, 2, 7, 4, 10, 1, 9, 8, 6] UpperCamelCase__ : Optional[int] = [2, 4, 3, 1] UpperCamelCase__ : List[Any] = [2, 6, 3, 1, 4, 8, 5, 7] UpperCamelCase__ : str = [4, 1, 3, 5, 7, 2, 8, 6] UpperCamelCase__ : List[Any] = [4, 1, 2, 3, 2, 3, 4, 1] UpperCamelCase__ : int = [[1, 0, 3, 2], [3, 2, 1, 0], [0, 2, 1, 3], [3, 1, 3, 2]] UpperCamelCase__ : Dict = [[0, 1, 2, 3], [2, 0, 1, 3], [3, 0, 1, 0], [2, 1, 0, 3]] # key generation UpperCamelCase__ : Optional[Any] = apply_table(key, paa_table) UpperCamelCase__ : str = temp[:5] UpperCamelCase__ : List[Any] = temp[5:] UpperCamelCase__ : Dict = left_shift(left) UpperCamelCase__ : Any = left_shift(right) UpperCamelCase__ : Optional[Any] = apply_table(left + right, pa_table) UpperCamelCase__ : List[str] = left_shift(left) UpperCamelCase__ : int = left_shift(right) UpperCamelCase__ : List[str] = left_shift(left) UpperCamelCase__ : Dict = left_shift(right) UpperCamelCase__ : List[str] = apply_table(left + right, pa_table) # encryption UpperCamelCase__ : Tuple = apply_table(message, IP) UpperCamelCase__ : Optional[Any] = function(expansion, sa, sa, keya, temp) UpperCamelCase__ : Optional[int] = temp[4:] + temp[:4] UpperCamelCase__ : Any = function(expansion, sa, sa, keya, temp) UpperCamelCase__ : Tuple = apply_table(temp, IP_inv) print("""Cipher text is:""", CT) # decryption UpperCamelCase__ : Union[str, Any] = apply_table(CT, IP) UpperCamelCase__ : List[str] = function(expansion, sa, sa, keya, temp) UpperCamelCase__ : Optional[Any] = temp[4:] + temp[:4] UpperCamelCase__ : Optional[int] = function(expansion, sa, sa, keya, temp) UpperCamelCase__ : Any = apply_table(temp, IP_inv) print("""Plain text after decypting is:""", PT)
330
0
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 lowerCamelCase_ ( unittest.TestCase ): def SCREAMING_SNAKE_CASE_ ( self : Any ): '''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(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ) processor.save_pretrained(self.tmpdirname ) def SCREAMING_SNAKE_CASE_ ( self : Dict ,**__lowerCamelCase : List[str] ): '''simple docstring''' return AutoProcessor.from_pretrained(self.tmpdirname ,**__lowerCamelCase ).tokenizer def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ,**__lowerCamelCase : Optional[int] ): '''simple docstring''' return AutoProcessor.from_pretrained(self.tmpdirname ,**__lowerCamelCase ).image_processor def SCREAMING_SNAKE_CASE_ ( self : Tuple ,**__lowerCamelCase : Optional[int] ): '''simple docstring''' return AutoProcessor.from_pretrained(self.tmpdirname ,**__lowerCamelCase ).qformer_tokenizer def SCREAMING_SNAKE_CASE_ ( self : int ): '''simple docstring''' shutil.rmtree(self.tmpdirname ) def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' a = [np.random.randint(2_55 ,size=(3, 30, 4_00) ,dtype=np.uinta )] a = [Image.fromarray(np.moveaxis(__lowerCamelCase ,0 ,-1 ) ) for x in image_inputs] return image_inputs def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ): '''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=__lowerCamelCase ,padding_value=1.0 ) a = InstructBlipProcessor.from_pretrained( self.tmpdirname ,bos_token='''(BOS)''' ,eos_token='''(EOS)''' ,do_normalize=__lowerCamelCase ,padding_value=1.0 ) self.assertEqual(processor.tokenizer.get_vocab() ,tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.tokenizer ,__lowerCamelCase ) self.assertEqual(processor.image_processor.to_json_string() ,image_processor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.image_processor ,__lowerCamelCase ) self.assertIsInstance(processor.qformer_tokenizer ,__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ): '''simple docstring''' a = self.get_image_processor() a = self.get_tokenizer() a = self.get_qformer_tokenizer() a = InstructBlipProcessor( tokenizer=__lowerCamelCase ,image_processor=__lowerCamelCase ,qformer_tokenizer=__lowerCamelCase ) a = self.prepare_image_inputs() a = image_processor(__lowerCamelCase ,return_tensors='''np''' ) a = processor(images=__lowerCamelCase ,return_tensors='''np''' ) for key in input_feat_extract.keys(): self.assertAlmostEqual(input_feat_extract[key].sum() ,input_processor[key].sum() ,delta=1e-2 ) def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' a = self.get_image_processor() a = self.get_tokenizer() a = self.get_qformer_tokenizer() a = InstructBlipProcessor( tokenizer=__lowerCamelCase ,image_processor=__lowerCamelCase ,qformer_tokenizer=__lowerCamelCase ) a = 'lower newer' a = processor(text=__lowerCamelCase ) a = tokenizer(__lowerCamelCase ,return_token_type_ids=__lowerCamelCase ) a = qformer_tokenizer(__lowerCamelCase ,return_token_type_ids=__lowerCamelCase ) 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 SCREAMING_SNAKE_CASE_ ( self : Tuple ): '''simple docstring''' a = self.get_image_processor() a = self.get_tokenizer() a = self.get_qformer_tokenizer() a = InstructBlipProcessor( tokenizer=__lowerCamelCase ,image_processor=__lowerCamelCase ,qformer_tokenizer=__lowerCamelCase ) a = 'lower newer' a = self.prepare_image_inputs() a = processor(text=__lowerCamelCase ,images=__lowerCamelCase ) 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(__lowerCamelCase ): processor() def SCREAMING_SNAKE_CASE_ ( self : int ): '''simple docstring''' a = self.get_image_processor() a = self.get_tokenizer() a = self.get_qformer_tokenizer() a = InstructBlipProcessor( tokenizer=__lowerCamelCase ,image_processor=__lowerCamelCase ,qformer_tokenizer=__lowerCamelCase ) a = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] a = processor.batch_decode(__lowerCamelCase ) a = tokenizer.batch_decode(__lowerCamelCase ) self.assertListEqual(__lowerCamelCase ,__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ): '''simple docstring''' a = self.get_image_processor() a = self.get_tokenizer() a = self.get_qformer_tokenizer() a = InstructBlipProcessor( tokenizer=__lowerCamelCase ,image_processor=__lowerCamelCase ,qformer_tokenizer=__lowerCamelCase ) a = 'lower newer' a = self.prepare_image_inputs() a = processor(text=__lowerCamelCase ,images=__lowerCamelCase ) self.assertListEqual( list(inputs.keys() ) ,['''input_ids''', '''attention_mask''', '''qformer_input_ids''', '''qformer_attention_mask''', '''pixel_values'''] ,)
351
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 lowerCamelCase_ ( unittest.TestCase ): @slow def SCREAMING_SNAKE_CASE_ ( self : Tuple ): '''simple docstring''' a = FlaxXLMRobertaModel.from_pretrained('''xlm-roberta-base''' ) a = AutoTokenizer.from_pretrained('''xlm-roberta-base''' ) a = '''The dog is cute and lives in the garden house''' a = jnp.array([tokenizer.encode(__lowerCamelCase )] ) a = (1, 12, 7_68) # batch_size, sequence_length, embedding_vector_dim a = jnp.array( [[-0.0_101, 0.1_218, -0.0_803, 0.0_801, 0.1_327, 0.0_776, -0.1_215, 0.2_383, 0.3_338, 0.3_106, 0.0_300, 0.0_252]] ) a = model(__lowerCamelCase )['''last_hidden_state'''] self.assertEqual(output.shape ,__lowerCamelCase ) # compare the actual values for a slice of last dim self.assertTrue(jnp.allclose(output[:, :, -1] ,__lowerCamelCase ,atol=1e-3 ) )
330
0
UpperCamelCase__ : int = { """A""": """.-""", """B""": """-...""", """C""": """-.-.""", """D""": """-..""", """E""": """.""", """F""": """..-.""", """G""": """--.""", """H""": """....""", """I""": """..""", """J""": """.---""", """K""": """-.-""", """L""": """.-..""", """M""": """--""", """N""": """-.""", """O""": """---""", """P""": """.--.""", """Q""": """--.-""", """R""": """.-.""", """S""": """...""", """T""": """-""", """U""": """..-""", """V""": """...-""", """W""": """.--""", """X""": """-..-""", """Y""": """-.--""", """Z""": """--..""", """1""": """.----""", """2""": """..---""", """3""": """...--""", """4""": """....-""", """5""": """.....""", """6""": """-....""", """7""": """--...""", """8""": """---..""", """9""": """----.""", """0""": """-----""", """&""": """.-...""", """@""": """.--.-.""", """:""": """---...""", """,""": """--..--""", """.""": """.-.-.-""", """'""": """.----.""", """\"""": """.-..-.""", """?""": """..--..""", """/""": """-..-.""", """=""": """-...-""", """+""": """.-.-.""", """-""": """-....-""", """(""": """-.--.""", """)""": """-.--.-""", """!""": """-.-.--""", """ """: """/""" } # Exclamation mark is not in ITU-R recommendation # fmt: on UpperCamelCase__ : List[str] = {value: key for key, value in MORSE_CODE_DICT.items()} def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> str: """simple docstring""" return " ".join(MORSE_CODE_DICT[char] for char in message.upper() ) def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> str: """simple docstring""" return "".join(REVERSE_DICT[char] for char in message.split() ) def SCREAMING_SNAKE_CASE__ ( ) -> None: """simple docstring""" a = '''Morse code here!''' print(snake_case_ ) a = encrypt(snake_case_ ) print(snake_case_ ) a = decrypt(snake_case_ ) print(snake_case_ ) if __name__ == "__main__": main()
352
import argparse import os # New Code # 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 import find_executable_batch_size ######################################################################## # This is a fully working simple example to use Accelerate, # specifically showcasing how to ensure out-of-memory errors never # interrupt training, and builds off the `nlp_example.py` script. # # 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) # # New additions from the base script can be found quickly by # looking for the # New Code # tags # # 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 # ######################################################################## UpperCamelCase__ : Union[str, Any] = 16 UpperCamelCase__ : Dict = 32 def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ = 1_6 ) -> Tuple: """simple docstring""" a = AutoTokenizer.from_pretrained('''bert-base-cased''' ) a = load_dataset('''glue''', '''mrpc''' ) def tokenize_function(snake_case_ ): # max_length=None => use the model max length (it's actually the default) a = 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(): a = 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 a = tokenized_datasets.rename_column('''label''', '''labels''' ) def collate_fn(snake_case_ ): # On TPU it's best to pad everything to the same length or training will be very slow. a = 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": a = 1_6 elif accelerator.mixed_precision != "no": a = 8 else: a = None return tokenizer.pad( snake_case_, padding='''longest''', max_length=snake_case_, pad_to_multiple_of=snake_case_, return_tensors='''pt''', ) # Instantiate dataloaders. a = DataLoader( tokenized_datasets['''train'''], shuffle=snake_case_, collate_fn=snake_case_, batch_size=snake_case_ ) a = 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 UpperCamelCase__ : int = mocked_dataloaders # noqa: F811 def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> List[Any]: """simple docstring""" if os.environ.get('''TESTING_MOCKED_DATALOADERS''', snake_case_ ) == "1": a = 2 # Initialize accelerator a = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision ) # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs a = config['''lr'''] a = int(config['''num_epochs'''] ) a = int(config['''seed'''] ) a = int(config['''batch_size'''] ) a = evaluate.load('''glue''', '''mrpc''' ) # New Code # # We now can define an inner training loop function. It should take a batch size as the only parameter, # and build the dataloaders in there. # It also gets our decorator @find_executable_batch_size(starting_batch_size=snake_case_ ) def inner_training_loop(snake_case_ ): # And now just move everything below under this function # We need to bring in the Accelerator object from earlier nonlocal accelerator # And reset all of its attributes that could hold onto any memory: accelerator.free_memory() # Then we can declare the model, optimizer, and everything else: set_seed(snake_case_ ) # Instantiate the model (we build the model here so that the seed also control new weights initialization) a = 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). a = model.to(accelerator.device ) # Instantiate optimizer a = AdamW(params=model.parameters(), lr=snake_case_ ) a , a = get_dataloaders(snake_case_, snake_case_ ) # Instantiate scheduler a = 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. a , a , a , a , a = 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() 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 ) a = model(**snake_case_ ) a = outputs.loss accelerator.backward(snake_case_ ) optimizer.step() lr_scheduler.step() optimizer.zero_grad() 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(): a = model(**snake_case_ ) a = outputs.logits.argmax(dim=-1 ) a , a = accelerator.gather_for_metrics((predictions, batch['''labels''']) ) metric.add_batch( predictions=snake_case_, references=snake_case_, ) a = metric.compute() # Use accelerator.print to print only on the main process. accelerator.print(f"""epoch {epoch}:""", snake_case_ ) # New Code # # And call it at the end with no arguments # Note: You could also refactor this outside of your training loop function inner_training_loop() def SCREAMING_SNAKE_CASE__ ( ) -> Tuple: """simple docstring""" a = 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.''', ) parser.add_argument('''--cpu''', action='''store_true''', help='''If passed, will train on the CPU.''' ) a = parser.parse_args() a = {'''lr''': 2e-5, '''num_epochs''': 3, '''seed''': 4_2, '''batch_size''': 1_6} training_function(snake_case_, snake_case_ ) if __name__ == "__main__": main()
330
0
import numpy as np import pandas as pd from sklearn.preprocessing import MinMaxScaler from tensorflow.keras.layers import LSTM, Dense from tensorflow.keras.models import Sequential if __name__ == "__main__": UpperCamelCase__ : Optional[Any] = pd.read_csv("""sample_data.csv""", header=None) UpperCamelCase__ : Dict = df.shape[:1][0] # If you're using some other dataset input the target column UpperCamelCase__ : Any = df.iloc[:, 1:2] UpperCamelCase__ : Optional[Any] = actual_data.values.reshape(len_data, 1) UpperCamelCase__ : Union[str, Any] = MinMaxScaler().fit_transform(actual_data) UpperCamelCase__ : str = 10 UpperCamelCase__ : Any = 5 UpperCamelCase__ : Optional[int] = 20 UpperCamelCase__ : Tuple = len_data - periods * look_back UpperCamelCase__ : int = actual_data[:division] UpperCamelCase__ : Tuple = actual_data[division - look_back :] UpperCamelCase__ , UpperCamelCase__ : List[str] = [], [] UpperCamelCase__ , UpperCamelCase__ : Optional[int] = [], [] for i in range(0, len(train_data) - forward_days - look_back + 1): train_x.append(train_data[i : i + look_back]) train_y.append(train_data[i + look_back : i + look_back + forward_days]) for i in range(0, len(test_data) - forward_days - look_back + 1): test_x.append(test_data[i : i + look_back]) test_y.append(test_data[i + look_back : i + look_back + forward_days]) UpperCamelCase__ : List[str] = np.array(train_x) UpperCamelCase__ : str = np.array(test_x) UpperCamelCase__ : Dict = np.array([list(i.ravel()) for i in train_y]) UpperCamelCase__ : int = np.array([list(i.ravel()) for i in test_y]) UpperCamelCase__ : Union[str, Any] = Sequential() model.add(LSTM(128, input_shape=(look_back, 1), return_sequences=True)) model.add(LSTM(64, input_shape=(128, 1))) model.add(Dense(forward_days)) model.compile(loss="""mean_squared_error""", optimizer="""adam""") UpperCamelCase__ : int = model.fit( x_train, y_train, epochs=150, verbose=1, shuffle=True, batch_size=4 ) UpperCamelCase__ : int = model.predict(x_test)
353
import argparse import fairseq import torch from transformers import UniSpeechSatConfig, UniSpeechSatForCTC, UniSpeechSatForPreTraining, logging logging.set_verbosity_info() UpperCamelCase__ : Optional[int] = logging.get_logger(__name__) UpperCamelCase__ : str = { """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""", """encoder.layer_norm_for_extract""": """layer_norm_for_extract""", """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""", """label_embs_concat""": """label_embeddings_concat""", """mask_emb""": """masked_spec_embed""", """spk_proj""": """speaker_proj""", } UpperCamelCase__ : Optional[Any] = [ """lm_head""", """quantizer.weight_proj""", """quantizer.codevectors""", """project_q""", """project_hid""", """label_embeddings_concat""", """speaker_proj""", """layer_norm_for_extract""", ] def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) -> List[Any]: """simple docstring""" for attribute in key.split('''.''' ): a = getattr(snake_case_, snake_case_ ) if weight_type is not None: a = getattr(snake_case_, snake_case_ ).shape else: a = 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 = value elif weight_type == "weight_g": a = value elif weight_type == "weight_v": a = value elif weight_type == "bias": a = value else: a = value logger.info(f"""{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.""" ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> Union[str, Any]: """simple docstring""" a = [] a = fairseq_model.state_dict() a = hf_model.unispeech_sat.feature_extractor for name, value in fairseq_dict.items(): a = False if "conv_layers" in name: load_conv_layer( snake_case_, snake_case_, snake_case_, snake_case_, hf_model.config.feat_extract_norm == '''group''', ) a = True else: for key, mapped_key in MAPPING.items(): a = '''unispeech_sat.''' + 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]: if "layer_norm_for_extract" in name and (".".join(name.split('''.''' )[:-1] ) != key): # special case since naming is very similar continue a = True if "*" in mapped_key: a = name.split(snake_case_ )[0].split('''.''' )[-2] a = mapped_key.replace('''*''', snake_case_ ) if "weight_g" in name: a = '''weight_g''' elif "weight_v" in name: a = '''weight_v''' elif "bias" in name: a = '''bias''' elif "weight" in name: # TODO: don't match quantizer.weight_proj a = '''weight''' else: a = None set_recursively(snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) continue if not is_used: unused_weights.append(snake_case_ ) logger.warning(f"""Unused weights: {unused_weights}""" ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) -> Union[str, Any]: """simple docstring""" a = full_name.split('''conv_layers.''' )[-1] a = name.split('''.''' ) a = int(items[0] ) a = 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 = 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 = 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[layer_id].layer_norm.bias.data.shape} was found.""" ) a = 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[layer_id].layer_norm.weight.data.shape} was found.""" ) a = value logger.info(f"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.""" ) else: unused_weights.append(snake_case_ ) @torch.no_grad() def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_=None, snake_case_=None, snake_case_=True ) -> Union[str, Any]: """simple docstring""" if config_path is not None: a = UniSpeechSatConfig.from_pretrained(snake_case_ ) else: a = UniSpeechSatConfig() a = '''''' if is_finetuned: a = UniSpeechSatForCTC(snake_case_ ) else: a = UniSpeechSatForPreTraining(snake_case_ ) a , a , a = fairseq.checkpoint_utils.load_model_ensemble_and_task( [checkpoint_path], arg_overrides={'''data''': '''/'''.join(dict_path.split('''/''' )[:-1] )} ) a = model[0].eval() recursively_load_weights(snake_case_, snake_case_ ) hf_wavavec.save_pretrained(snake_case_ ) if __name__ == "__main__": UpperCamelCase__ : Optional[int] = argparse.ArgumentParser() parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""") parser.add_argument("""--checkpoint_path""", default=None, type=str, help="""Path to fairseq checkpoint""") parser.add_argument("""--dict_path""", default=None, type=str, help="""Path to dict of fine-tuned model""") parser.add_argument("""--config_path""", default=None, type=str, help="""Path to hf config.json of model to convert""") parser.add_argument( """--not_finetuned""", action="""store_true""", help="""Whether the model to convert is a fine-tuned model or not""" ) UpperCamelCase__ : int = parser.parse_args() convert_unispeech_sat_checkpoint( args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned )
330
0
from math import factorial def SCREAMING_SNAKE_CASE__ ( snake_case_ = 2_0 ) -> int: """simple docstring""" a = 2 * n # middle entry of odd rows starting at row 3 is the solution for n = 1, # 2, 3,... a = n // 2 return int(factorial(_lowerCAmelCase ) / (factorial(_lowerCAmelCase ) * factorial(n - k )) ) if __name__ == "__main__": import sys if len(sys.argv) == 1: print(solution(20)) else: try: UpperCamelCase__ : Union[str, Any] = int(sys.argv[1]) print(solution(n)) except ValueError: print("""Invalid entry - please enter a number.""")
354
import pytest from datasets import inspect_metric, list_metrics, load_metric @pytest.fixture def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> List[str]: """simple docstring""" monkeypatch.setattr('''datasets.utils.deprecation_utils._emitted_deprecation_warnings''', set() ) @pytest.fixture def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Optional[int]: """simple docstring""" class lowerCamelCase_ : def __init__( self : Dict ,__lowerCamelCase : List[str] ): '''simple docstring''' a = metric_id class lowerCamelCase_ : SCREAMING_SNAKE_CASE_ = [MetricMock(a_ ) for metric_id in ['accuracy', 'mse', 'precision', 'codeparrot/apps_metric']] def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' return self._metrics monkeypatch.setattr('''datasets.inspect.huggingface_hub''', HfhMock() ) @pytest.mark.parametrize( '''func, args''', [(load_metric, ('''metrics/mse''',)), (list_metrics, ()), (inspect_metric, ('''metrics/mse''', '''tmp_path'''))] ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) -> Tuple: """simple docstring""" if "tmp_path" in args: a = tuple(arg if arg != '''tmp_path''' else tmp_path for arg in args ) with pytest.warns(snake_case_, match='''https://huggingface.co/docs/evaluate''' ): func(*snake_case_ )
330
0
"""simple docstring""" import argparse import logging import os import time import timeit import datasets import numpy as np import pycuda.autoinit # noqa: F401 import pycuda.driver as cuda import tensorrt as trt import torch from absl import logging as absl_logging from accelerate import Accelerator from datasets import load_dataset, load_metric from torch.utils.data import DataLoader from utils_qa import postprocess_qa_predictions import transformers from transformers import AutoTokenizer, EvalPrediction, default_data_collator, set_seed from transformers.trainer_pt_utils import nested_concat, nested_truncate UpperCamelCase__ : Tuple = trt.Logger(trt.Logger.WARNING) UpperCamelCase__ : Dict = absl_logging.get_absl_logger() absl_logger.setLevel(logging.WARNING) UpperCamelCase__ : List[Any] = logging.getLogger(__name__) UpperCamelCase__ : int = argparse.ArgumentParser() # Required parameters parser.add_argument( """--onnx_model_path""", default=None, type=str, required=True, help="""Path to ONNX model: """, ) parser.add_argument( """--output_dir""", default=None, type=str, required=True, help="""The output directory where the model checkpoints and predictions will be written.""", ) # Other parameters parser.add_argument( """--tokenizer_name""", default="""""", type=str, required=True, help="""Pretrained tokenizer name or path if not the same as model_name""", ) parser.add_argument( """--version_2_with_negative""", action="""store_true""", help="""If true, the SQuAD examples contain some that do not have an answer.""", ) parser.add_argument( """--null_score_diff_threshold""", type=float, default=0.0, help="""If null_score - best_non_null is greater than the threshold predict null.""", ) parser.add_argument( """--max_seq_length""", default=384, type=int, help=( """The maximum total input sequence length after WordPiece tokenization. Sequences """ """longer than this will be truncated, and sequences shorter than this will be padded.""" ), ) parser.add_argument( """--doc_stride""", default=128, type=int, help="""When splitting up a long document into chunks, how much stride to take between chunks.""", ) parser.add_argument("""--per_device_eval_batch_size""", default=8, type=int, help="""Batch size per GPU/CPU for evaluation.""") parser.add_argument( """--n_best_size""", default=20, type=int, help="""The total number of n-best predictions to generate in the nbest_predictions.json output file.""", ) parser.add_argument( """--max_answer_length""", default=30, type=int, help=( """The maximum length of an answer that can be generated. This is needed because the start """ """and end predictions are not conditioned on one another.""" ), ) parser.add_argument("""--seed""", type=int, default=42, help="""random seed for initialization""") parser.add_argument( """--dataset_name""", type=str, default=None, required=True, help="""The name of the dataset to use (via the datasets library).""", ) parser.add_argument( """--dataset_config_name""", type=str, default=None, help="""The configuration name of the dataset to use (via the datasets library).""", ) parser.add_argument( """--preprocessing_num_workers""", type=int, default=4, help="""A csv or a json file containing the training data.""" ) parser.add_argument("""--overwrite_cache""", action="""store_true""", help="""Overwrite the cached training and evaluation sets""") parser.add_argument( """--fp16""", action="""store_true""", help="""Whether to use 16-bit (mixed) precision instead of 32-bit""", ) parser.add_argument( """--int8""", action="""store_true""", help="""Whether to use INT8""", ) UpperCamelCase__ : int = parser.parse_args() if args.tokenizer_name: UpperCamelCase__ : Optional[int] = AutoTokenizer.from_pretrained(args.tokenizer_name, use_fast=True) else: raise ValueError( """You are instantiating a new tokenizer from scratch. This is not supported by this script.""" """You can do it from another script, save it, and load it from here, using --tokenizer_name.""" ) logger.info("""Training/evaluation parameters %s""", args) UpperCamelCase__ : Optional[int] = args.per_device_eval_batch_size UpperCamelCase__ : List[str] = (args.eval_batch_size, args.max_seq_length) # TRT Engine properties UpperCamelCase__ : Any = True UpperCamelCase__ : List[Any] = 'temp_engine/bert-fp32.engine' if args.fpaa: UpperCamelCase__ : Dict = 'temp_engine/bert-fp16.engine' if args.inta: UpperCamelCase__ : int = 'temp_engine/bert-int8.engine' # import ONNX file if not os.path.exists("""temp_engine"""): os.makedirs("""temp_engine""") UpperCamelCase__ : Dict = 1 << (int)(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH) with trt.Builder(TRT_LOGGER) as builder, builder.create_network(EXPLICIT_BATCH) as network, trt.OnnxParser( network, TRT_LOGGER ) as parser: with open(args.onnx_model_path, """rb""") as model: if not parser.parse(model.read()): for error in range(parser.num_errors): print(parser.get_error(error)) # Query input names and shapes from parsed TensorRT network UpperCamelCase__ : Tuple = [network.get_input(i) for i in range(network.num_inputs)] UpperCamelCase__ : int = [_input.name for _input in network_inputs] # ex: ["actual_input1"] with builder.create_builder_config() as config: UpperCamelCase__ : Optional[Any] = 1 << 50 if STRICT_TYPES: config.set_flag(trt.BuilderFlag.STRICT_TYPES) if args.fpaa: config.set_flag(trt.BuilderFlag.FPaa) if args.inta: config.set_flag(trt.BuilderFlag.INTa) UpperCamelCase__ : Dict = builder.create_optimization_profile() config.add_optimization_profile(profile) for i in range(len(input_names)): profile.set_shape(input_names[i], INPUT_SHAPE, INPUT_SHAPE, INPUT_SHAPE) UpperCamelCase__ : List[Any] = builder.build_engine(network, config) # serialize_engine and store in file (can be directly loaded and deserialized): with open(engine_name, """wb""") as f: f.write(engine.serialize()) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) -> Dict: """simple docstring""" a = np.asarray(inputs['''input_ids'''], dtype=np.intaa ) a = np.asarray(inputs['''attention_mask'''], dtype=np.intaa ) a = np.asarray(inputs['''token_type_ids'''], dtype=np.intaa ) # Copy inputs cuda.memcpy_htod_async(d_inputs[0], input_ids.ravel(), _A ) cuda.memcpy_htod_async(d_inputs[1], attention_mask.ravel(), _A ) cuda.memcpy_htod_async(d_inputs[2], token_type_ids.ravel(), _A ) # start time a = time.time() # Run inference context.execute_async( bindings=[int(_A ) for d_inp in d_inputs] + [int(_A ), int(_A )], stream_handle=stream.handle ) # Transfer predictions back from GPU cuda.memcpy_dtoh_async(_A, _A, _A ) cuda.memcpy_dtoh_async(_A, _A, _A ) # Synchronize the stream and take time stream.synchronize() # end time a = time.time() a = end_time - start_time a = (h_outputa, h_outputa) # print(outputs) return outputs, infer_time # Initialize the accelerator. We will let the accelerator handle device placement for us in this example. UpperCamelCase__ : Dict = Accelerator() # Make one log on every process with the configuration for debugging. logging.basicConfig( format="""%(asctime)s - %(levelname)s - %(name)s - %(message)s""", datefmt="""%m/%d/%Y %H:%M:%S""", level=logging.INFO, ) # Setup logging, we only want one process per machine to log things on the screen. # accelerator.is_local_main_process is only True for one process per machine. logger.setLevel(logging.INFO if accelerator.is_local_main_process else logging.ERROR) if accelerator.is_local_main_process: datasets.utils.logging.set_verbosity_warning() transformers.utils.logging.set_verbosity_info() else: datasets.utils.logging.set_verbosity_error() transformers.utils.logging.set_verbosity_error() # If passed along, set the training seed now. if args.seed is not None: set_seed(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). if args.dataset_name is not None: # Downloading and loading a dataset from the hub. UpperCamelCase__ : Optional[Any] = load_dataset(args.dataset_name, args.dataset_config_name) else: raise ValueError("""Evaluation requires a dataset name""") # 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. # Preprocessing the datasets. # Preprocessing is slighlty different for training and evaluation. UpperCamelCase__ : Any = raw_datasets['validation'].column_names UpperCamelCase__ : Any = 'question' if 'question' in column_names else column_names[0] UpperCamelCase__ : Optional[int] = 'context' if 'context' in column_names else column_names[1] UpperCamelCase__ : Tuple = 'answers' if 'answers' in column_names else column_names[2] # Padding side determines if we do (question|context) or (context|question). UpperCamelCase__ : Optional[Any] = tokenizer.padding_side == 'right' if args.max_seq_length > tokenizer.model_max_length: logger.warning( F"The max_seq_length passed ({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__ : int = min(args.max_seq_length, tokenizer.model_max_length) def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Union[str, Any]: """simple docstring""" a = [q.lstrip() for q in examples[question_column_name]] # Tokenize our examples with truncation and maybe padding, but keep the overflows using a stride. This results # in one example possible giving several features when a context is long, each of those features having a # context that overlaps a bit the context of the previous feature. a = tokenizer( examples[question_column_name if pad_on_right else context_column_name], examples[context_column_name if pad_on_right else question_column_name], truncation='''only_second''' if pad_on_right else '''only_first''', max_length=_A, stride=args.doc_stride, return_overflowing_tokens=_A, return_offsets_mapping=_A, padding='''max_length''', ) # Since one example might give us several features if it has a long context, we need a map from a feature to # its corresponding example. This key gives us just that. a = tokenized_examples.pop('''overflow_to_sample_mapping''' ) # For evaluation, we will need to convert our predictions to substrings of the context, so we keep the # corresponding example_id and we will store the offset mappings. a = [] for i in range(len(tokenized_examples['''input_ids'''] ) ): # Grab the sequence corresponding to that example (to know what is the context and what is the question). a = tokenized_examples.sequence_ids(_A ) a = 1 if pad_on_right else 0 # One example can give several spans, this is the index of the example containing this span of text. a = sample_mapping[i] tokenized_examples["example_id"].append(examples['''id'''][sample_index] ) # Set to None the offset_mapping that are not part of the context so it's easy to determine if a token # position is part of the context or not. a = [ (o if sequence_ids[k] == context_index else None) for k, o in enumerate(tokenized_examples['''offset_mapping'''][i] ) ] return tokenized_examples UpperCamelCase__ : Optional[Any] = raw_datasets['validation'] # Validation Feature Creation UpperCamelCase__ : List[Any] = eval_examples.map( prepare_validation_features, batched=True, num_proc=args.preprocessing_num_workers, remove_columns=column_names, load_from_cache_file=not args.overwrite_cache, desc="""Running tokenizer on validation dataset""", ) UpperCamelCase__ : int = default_data_collator UpperCamelCase__ : Optional[Any] = eval_dataset.remove_columns(["""example_id""", """offset_mapping"""]) UpperCamelCase__ : Tuple = DataLoader( eval_dataset_for_model, collate_fn=data_collator, batch_size=args.per_device_eval_batch_size ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_="eval" ) -> Dict: """simple docstring""" a = postprocess_qa_predictions( examples=_A, features=_A, predictions=_A, version_2_with_negative=args.version_2_with_negative, n_best_size=args.n_best_size, max_answer_length=args.max_answer_length, null_score_diff_threshold=args.null_score_diff_threshold, output_dir=args.output_dir, prefix=_A, ) # Format the result to the format the metric expects. if args.version_2_with_negative: a = [ {'''id''': k, '''prediction_text''': v, '''no_answer_probability''': 0.0} for k, v in predictions.items() ] else: a = [{'''id''': k, '''prediction_text''': v} for k, v in predictions.items()] a = [{'''id''': ex['''id'''], '''answers''': ex[answer_column_name]} for ex in examples] return EvalPrediction(predictions=_A, label_ids=_A ) UpperCamelCase__ : Optional[int] = load_metric("""squad_v2""" if args.version_2_with_negative else """squad""") # Evaluation! logger.info("""Loading ONNX model %s for evaluation""", args.onnx_model_path) with open(engine_name, """rb""") as f, trt.Runtime(TRT_LOGGER) as runtime, runtime.deserialize_cuda_engine( f.read() ) as engine, engine.create_execution_context() as context: # setup for TRT inferrence for i in range(len(input_names)): context.set_binding_shape(i, INPUT_SHAPE) assert context.all_binding_shapes_specified def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Dict: """simple docstring""" return trt.volume(engine.get_binding_shape(_A ) ) * engine.get_binding_dtype(_A ).itemsize # Allocate device memory for inputs and outputs. UpperCamelCase__ : Union[str, Any] = [cuda.mem_alloc(binding_nbytes(binding)) for binding in engine if engine.binding_is_input(binding)] # Allocate output buffer UpperCamelCase__ : Dict = cuda.pagelocked_empty(tuple(context.get_binding_shape(3)), dtype=np.floataa) UpperCamelCase__ : int = cuda.pagelocked_empty(tuple(context.get_binding_shape(4)), dtype=np.floataa) UpperCamelCase__ : Any = cuda.mem_alloc(h_outputa.nbytes) UpperCamelCase__ : str = cuda.mem_alloc(h_outputa.nbytes) # Create a stream in which to copy inputs/outputs and run inference. UpperCamelCase__ : List[Any] = cuda.Stream() # Evaluation logger.info("""***** Running Evaluation *****""") logger.info(F" Num examples = {len(eval_dataset)}") logger.info(F" Batch size = {args.per_device_eval_batch_size}") UpperCamelCase__ : Dict = 0.0 UpperCamelCase__ : str = 0 UpperCamelCase__ : Optional[Any] = timeit.default_timer() UpperCamelCase__ : Union[str, Any] = None for step, batch in enumerate(eval_dataloader): UpperCamelCase__ : Tuple = model_infer(batch, context, d_inputs, h_outputa, h_outputa, d_outputa, d_outputa, stream) total_time += infer_time niter += 1 UpperCamelCase__ : Union[str, Any] = outputs UpperCamelCase__ : Tuple = torch.tensor(start_logits) UpperCamelCase__ : Tuple = torch.tensor(end_logits) # necessary to pad predictions and labels for being gathered UpperCamelCase__ : List[Any] = accelerator.pad_across_processes(start_logits, dim=1, pad_index=-100) UpperCamelCase__ : List[str] = accelerator.pad_across_processes(end_logits, dim=1, pad_index=-100) UpperCamelCase__ : Tuple = (accelerator.gather(start_logits).cpu().numpy(), accelerator.gather(end_logits).cpu().numpy()) UpperCamelCase__ : str = logits if all_preds is None else nested_concat(all_preds, logits, padding_index=-100) if all_preds is not None: UpperCamelCase__ : List[str] = nested_truncate(all_preds, len(eval_dataset)) UpperCamelCase__ : List[str] = timeit.default_timer() - start_time logger.info(""" Evaluation done in total %f secs (%f sec per example)""", evalTime, evalTime / len(eval_dataset)) # Inference time from TRT logger.info("""Average Inference Time = {:.3f} ms""".format(total_time * 1_000 / niter)) logger.info("""Total Inference Time = {:.3f} ms""".format(total_time * 1_000)) logger.info("""Total Number of Inference = %d""", niter) UpperCamelCase__ : int = post_processing_function(eval_examples, eval_dataset, all_preds) UpperCamelCase__ : Tuple = metric.compute(predictions=prediction.predictions, references=prediction.label_ids) logger.info(F"Evaluation metrics: {eval_metric}")
355
from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCamelCase__ : str = logging.get_logger(__name__) UpperCamelCase__ : Optional[int] = { """studio-ousia/luke-base""": """https://huggingface.co/studio-ousia/luke-base/resolve/main/config.json""", """studio-ousia/luke-large""": """https://huggingface.co/studio-ousia/luke-large/resolve/main/config.json""", } class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = 'luke' def __init__( self : Dict ,__lowerCamelCase : Optional[Any]=5_02_67 ,__lowerCamelCase : str=50_00_00 ,__lowerCamelCase : Any=7_68 ,__lowerCamelCase : int=2_56 ,__lowerCamelCase : Optional[int]=12 ,__lowerCamelCase : Tuple=12 ,__lowerCamelCase : Any=30_72 ,__lowerCamelCase : Any="gelu" ,__lowerCamelCase : Any=0.1 ,__lowerCamelCase : Tuple=0.1 ,__lowerCamelCase : Tuple=5_12 ,__lowerCamelCase : int=2 ,__lowerCamelCase : Optional[int]=0.02 ,__lowerCamelCase : List[Any]=1e-12 ,__lowerCamelCase : Dict=True ,__lowerCamelCase : Tuple=None ,__lowerCamelCase : Any=1 ,__lowerCamelCase : Dict=0 ,__lowerCamelCase : Any=2 ,**__lowerCamelCase : str ,): '''simple docstring''' super().__init__(pad_token_id=__lowerCamelCase ,bos_token_id=__lowerCamelCase ,eos_token_id=__lowerCamelCase ,**__lowerCamelCase ) a = vocab_size a = entity_vocab_size a = hidden_size a = entity_emb_size a = num_hidden_layers a = num_attention_heads a = hidden_act a = intermediate_size a = hidden_dropout_prob a = attention_probs_dropout_prob a = max_position_embeddings a = type_vocab_size a = initializer_range a = layer_norm_eps a = use_entity_aware_attention a = classifier_dropout
330
0
from __future__ import annotations UpperCamelCase__ : List[str] = tuple[int, int, int] UpperCamelCase__ : int = tuple[str, str, str] # used alphabet -------------------------- # from string.ascii_uppercase UpperCamelCase__ : Optional[Any] = """ABCDEFGHIJKLMNOPQRSTUVWXYZ""" # -------------------------- default selection -------------------------- # rotors -------------------------- UpperCamelCase__ : List[Any] = """EGZWVONAHDCLFQMSIPJBYUKXTR""" UpperCamelCase__ : Optional[int] = """FOBHMDKEXQNRAULPGSJVTYICZW""" UpperCamelCase__ : Optional[int] = """ZJXESIUQLHAVRMDOYGTNFWPBKC""" # reflector -------------------------- UpperCamelCase__ : Tuple = { """A""": """N""", """N""": """A""", """B""": """O""", """O""": """B""", """C""": """P""", """P""": """C""", """D""": """Q""", """Q""": """D""", """E""": """R""", """R""": """E""", """F""": """S""", """S""": """F""", """G""": """T""", """T""": """G""", """H""": """U""", """U""": """H""", """I""": """V""", """V""": """I""", """J""": """W""", """W""": """J""", """K""": """X""", """X""": """K""", """L""": """Y""", """Y""": """L""", """M""": """Z""", """Z""": """M""", } # -------------------------- extra rotors -------------------------- UpperCamelCase__ : List[Any] = """RMDJXFUWGISLHVTCQNKYPBEZOA""" UpperCamelCase__ : Union[str, Any] = """SGLCPQWZHKXAREONTFBVIYJUDM""" UpperCamelCase__ : Any = """HVSICLTYKQUBXDWAJZOMFGPREN""" UpperCamelCase__ : Any = """RZWQHFMVDBKICJLNTUXAGYPSOE""" UpperCamelCase__ : Dict = """LFKIJODBEGAMQPXVUHYSTCZRWN""" UpperCamelCase__ : List[str] = """KOAEGVDHXPQZMLFTYWJNBRCIUS""" def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> Optional[Any]: """simple docstring""" if (unique_rotsel := len(set(snake_case_ ) )) < 3: a = f"""Please use 3 unique rotors (not {unique_rotsel})""" raise Exception(snake_case_ ) # Checks if rotor positions are valid a = rotpos if not 0 < rotorposa <= len(snake_case_ ): a = f"""First rotor position is not within range of 1..26 ({rotorposa}""" raise ValueError(snake_case_ ) if not 0 < rotorposa <= len(snake_case_ ): a = f"""Second rotor position is not within range of 1..26 ({rotorposa})""" raise ValueError(snake_case_ ) if not 0 < rotorposa <= len(snake_case_ ): a = f"""Third rotor position is not within range of 1..26 ({rotorposa})""" raise ValueError(snake_case_ ) # Validates string and returns dict a = _plugboard(snake_case_ ) return rotpos, rotsel, pbdict def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Optional[int]: """simple docstring""" if not isinstance(snake_case_, snake_case_ ): a = f"""Plugboard setting isn't type string ({type(snake_case_ )})""" raise TypeError(snake_case_ ) elif len(snake_case_ ) % 2 != 0: a = f"""Odd number of symbols ({len(snake_case_ )})""" raise Exception(snake_case_ ) elif pbstring == "": return {} pbstring.replace(''' ''', '''''' ) # Checks if all characters are unique a = set() for i in pbstring: if i not in abc: a = f"""'{i}' not in list of symbols""" raise Exception(snake_case_ ) elif i in tmppbl: a = f"""Duplicate symbol ({i})""" raise Exception(snake_case_ ) else: tmppbl.add(snake_case_ ) del tmppbl # Created the dictionary a = {} for j in range(0, len(snake_case_ ) - 1, 2 ): a = pbstring[j + 1] a = pbstring[j] return pb def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ = (rotora, rotora, rotora), snake_case_ = "", ) -> Dict: """simple docstring""" a = text.upper() a = _validator( snake_case_, snake_case_, plugb.upper() ) a = rotor_position a = rotor_selection rotorposa -= 1 rotorposa -= 1 rotorposa -= 1 a = [] # encryption/decryption process -------------------------- for symbol in text: if symbol in abc: # 1st plugboard -------------------------- if symbol in plugboard: a = plugboard[symbol] # rotor ra -------------------------- a = abc.index(snake_case_ ) + rotorposa a = rotora[index % len(snake_case_ )] # rotor rb -------------------------- a = abc.index(snake_case_ ) + rotorposa a = rotora[index % len(snake_case_ )] # rotor rc -------------------------- a = abc.index(snake_case_ ) + rotorposa a = rotora[index % len(snake_case_ )] # reflector -------------------------- # this is the reason you don't need another machine to decipher a = reflector[symbol] # 2nd rotors a = abc[rotora.index(snake_case_ ) - rotorposa] a = abc[rotora.index(snake_case_ ) - rotorposa] a = abc[rotora.index(snake_case_ ) - rotorposa] # 2nd plugboard if symbol in plugboard: a = plugboard[symbol] # moves/resets rotor positions rotorposa += 1 if rotorposa >= len(snake_case_ ): a = 0 rotorposa += 1 if rotorposa >= len(snake_case_ ): a = 0 rotorposa += 1 if rotorposa >= len(snake_case_ ): a = 0 # else: # pass # Error could be also raised # raise ValueError( # 'Invalid symbol('+repr(symbol)+')') result.append(snake_case_ ) return "".join(snake_case_ ) if __name__ == "__main__": UpperCamelCase__ : Union[str, Any] = """This is my Python script that emulates the Enigma machine from WWII.""" UpperCamelCase__ : int = (1, 1, 1) UpperCamelCase__ : Dict = """pictures""" UpperCamelCase__ : str = (rotora, rotora, rotora) UpperCamelCase__ : Union[str, Any] = enigma(message, rotor_pos, rotor_sel, pb) print("""Encrypted message:""", en) print("""Decrypted message:""", enigma(en, rotor_pos, rotor_sel, pb))
356
import numpy as np import pandas as pd from sklearn.preprocessing import MinMaxScaler from tensorflow.keras.layers import LSTM, Dense from tensorflow.keras.models import Sequential if __name__ == "__main__": UpperCamelCase__ : Optional[int] = pd.read_csv("""sample_data.csv""", header=None) UpperCamelCase__ : Tuple = df.shape[:1][0] # If you're using some other dataset input the target column UpperCamelCase__ : List[Any] = df.iloc[:, 1:2] UpperCamelCase__ : Union[str, Any] = actual_data.values.reshape(len_data, 1) UpperCamelCase__ : List[Any] = MinMaxScaler().fit_transform(actual_data) UpperCamelCase__ : Optional[Any] = 10 UpperCamelCase__ : int = 5 UpperCamelCase__ : List[str] = 20 UpperCamelCase__ : Optional[int] = len_data - periods * look_back UpperCamelCase__ : Union[str, Any] = actual_data[:division] UpperCamelCase__ : str = actual_data[division - look_back :] UpperCamelCase__ , UpperCamelCase__ : Union[str, Any] = [], [] UpperCamelCase__ , UpperCamelCase__ : str = [], [] for i in range(0, len(train_data) - forward_days - look_back + 1): train_x.append(train_data[i : i + look_back]) train_y.append(train_data[i + look_back : i + look_back + forward_days]) for i in range(0, len(test_data) - forward_days - look_back + 1): test_x.append(test_data[i : i + look_back]) test_y.append(test_data[i + look_back : i + look_back + forward_days]) UpperCamelCase__ : List[str] = np.array(train_x) UpperCamelCase__ : Optional[Any] = np.array(test_x) UpperCamelCase__ : Tuple = np.array([list(i.ravel()) for i in train_y]) UpperCamelCase__ : Optional[Any] = np.array([list(i.ravel()) for i in test_y]) UpperCamelCase__ : Union[str, Any] = Sequential() model.add(LSTM(128, input_shape=(look_back, 1), return_sequences=True)) model.add(LSTM(64, input_shape=(128, 1))) model.add(Dense(forward_days)) model.compile(loss="""mean_squared_error""", optimizer="""adam""") UpperCamelCase__ : Tuple = model.fit( x_train, y_train, epochs=150, verbose=1, shuffle=True, batch_size=4 ) UpperCamelCase__ : Tuple = model.predict(x_test)
330
0
import copy from dataclasses import dataclass, field from typing import ClassVar, Dict from ..features import Audio, Features, Value from .base import TaskTemplate @dataclass(frozen=__lowerCAmelCase ) class lowerCamelCase_ ( __lowerCAmelCase ): SCREAMING_SNAKE_CASE_ = field(default='automatic-speech-recognition' , metadata={'include_in_asdict_even_if_is_default': True} ) SCREAMING_SNAKE_CASE_ = Features({'audio': Audio()} ) SCREAMING_SNAKE_CASE_ = Features({'transcription': Value('string' )} ) SCREAMING_SNAKE_CASE_ = "audio" SCREAMING_SNAKE_CASE_ = "transcription" def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : Dict ): '''simple docstring''' if self.audio_column not in features: raise ValueError(F"""Column {self.audio_column} is not present in features.""" ) if not isinstance(features[self.audio_column] ,lowerCamelCase__ ): raise ValueError(F"""Column {self.audio_column} is not an Audio type.""" ) a = copy.deepcopy(self ) a = self.input_schema.copy() a = features[self.audio_column] a = input_schema return task_template @property def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ): '''simple docstring''' return {self.audio_column: "audio", self.transcription_column: "transcription"}
357
import os import time import pytest from datasets.utils.filelock import FileLock, Timeout def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Tuple: """simple docstring""" a = FileLock(str(tmpdir / '''foo.lock''' ) ) a = FileLock(str(tmpdir / '''foo.lock''' ) ) a = 0.01 with locka.acquire(): with pytest.raises(snake_case_ ): a = time.time() locka.acquire(snake_case_ ) assert time.time() - _start > timeout def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Optional[int]: """simple docstring""" a = '''a''' * 1_0_0_0 + '''.lock''' a = FileLock(str(tmpdir / filename ) ) assert locka._lock_file.endswith('''.lock''' ) assert not locka._lock_file.endswith(snake_case_ ) assert len(os.path.basename(locka._lock_file ) ) <= 2_5_5 a = FileLock(tmpdir / filename ) with locka.acquire(): with pytest.raises(snake_case_ ): locka.acquire(0 )
330
0
UpperCamelCase__ : List[Any] = { """A""": ["""B""", """C""", """E"""], """B""": ["""A""", """D""", """E"""], """C""": ["""A""", """F""", """G"""], """D""": ["""B"""], """E""": ["""A""", """B""", """D"""], """F""": ["""C"""], """G""": ["""C"""], } def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> Union[str, Any]: """simple docstring""" a = set() # keep track of all the paths to be checked a = [[start]] # return path if start is goal if start == goal: return [start] # keeps looping until all possible paths have been checked while queue: # pop the first path from the queue a = queue.pop(0 ) # get the last node from the path a = path[-1] if node not in explored: a = graph[node] # go through all neighbour nodes, construct a new path and # push it into the queue for neighbour in neighbours: a = list(A__ ) new_path.append(A__ ) queue.append(A__ ) # return path if neighbour is goal if neighbour == goal: return new_path # mark node as explored explored.add(A__ ) # in case there's no path between the 2 nodes return [] def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> List[Any]: """simple docstring""" if not graph or start not in graph or target not in graph: return -1 if start == target: return 0 a = [start] a = set(A__ ) # Keep tab on distances from `start` node. a = {start: 0, target: -1} while queue: a = queue.pop(0 ) if node == target: a = ( dist[node] if dist[target] == -1 else min(dist[target], dist[node] ) ) for adjacent in graph[node]: if adjacent not in visited: visited.add(A__ ) queue.append(A__ ) a = dist[node] + 1 return dist[target] if __name__ == "__main__": print(bfs_shortest_path(demo_graph, """G""", """D""")) # returns ['G', 'C', 'A', 'B', 'D'] print(bfs_shortest_path_distance(demo_graph, """G""", """D""")) # returns 4
358
from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCamelCase__ : Optional[int] = logging.get_logger(__name__) UpperCamelCase__ : Dict = { """facebook/vit-mae-base""": """https://huggingface.co/facebook/vit-mae-base/resolve/main/config.json""", # See all ViT MAE models at https://huggingface.co/models?filter=vit-mae } class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = 'vit_mae' def __init__( self : Dict ,__lowerCamelCase : Any=7_68 ,__lowerCamelCase : Optional[Any]=12 ,__lowerCamelCase : List[str]=12 ,__lowerCamelCase : Optional[int]=30_72 ,__lowerCamelCase : int="gelu" ,__lowerCamelCase : Union[str, Any]=0.0 ,__lowerCamelCase : Optional[int]=0.0 ,__lowerCamelCase : Dict=0.02 ,__lowerCamelCase : List[Any]=1e-12 ,__lowerCamelCase : Dict=2_24 ,__lowerCamelCase : str=16 ,__lowerCamelCase : Union[str, Any]=3 ,__lowerCamelCase : Optional[Any]=True ,__lowerCamelCase : Dict=16 ,__lowerCamelCase : List[str]=5_12 ,__lowerCamelCase : int=8 ,__lowerCamelCase : int=20_48 ,__lowerCamelCase : Optional[Any]=0.75 ,__lowerCamelCase : int=False ,**__lowerCamelCase : Any ,): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = hidden_size a = num_hidden_layers a = num_attention_heads a = intermediate_size a = hidden_act a = hidden_dropout_prob a = attention_probs_dropout_prob a = initializer_range a = layer_norm_eps a = image_size a = patch_size a = num_channels a = qkv_bias a = decoder_num_attention_heads a = decoder_hidden_size a = decoder_num_hidden_layers a = decoder_intermediate_size a = mask_ratio a = norm_pix_loss
330
0
import datasets from .evaluate import evaluate UpperCamelCase__ : str = '\\n@article{hendrycks2021cuad,\n title={CUAD: An Expert-Annotated NLP Dataset for Legal Contract Review},\n author={Dan Hendrycks and Collin Burns and Anya Chen and Spencer Ball},\n journal={arXiv preprint arXiv:2103.06268},\n year={2021}\n}\n' UpperCamelCase__ : int = '\nThis metric wrap the official scoring script for version 1 of the Contract\nUnderstanding Atticus Dataset (CUAD).\nContract Understanding Atticus Dataset (CUAD) v1 is a corpus of more than 13,000 labels in 510\ncommercial legal contracts that have been manually labeled to identify 41 categories of important\nclauses that lawyers look for when reviewing contracts in connection with corporate transactions.\n' UpperCamelCase__ : Optional[Any] = '\nComputes CUAD scores (EM, F1, AUPR, Precision@80%Recall, and Precision@90%Recall).\nArgs:\n predictions: List of question-answers dictionaries with the following key-values:\n - \'id\': id of the question-answer pair as given in the references (see below)\n - \'prediction_text\': list of possible texts for the answer, as a list of strings\n depending on a threshold on the confidence probability of each prediction.\n references: List of question-answers dictionaries with the following key-values:\n - \'id\': id of the question-answer pair (see above),\n - \'answers\': a Dict in the CUAD dataset format\n {\n \'text\': list of possible texts for the answer, as a list of strings\n \'answer_start\': list of start positions for the answer, as a list of ints\n }\n Note that answer_start values are not taken into account to compute the metric.\nReturns:\n \'exact_match\': Exact match (the normalized answer exactly match the gold answer)\n \'f1\': The F-score of predicted tokens versus the gold answer\n \'aupr\': Area Under the Precision-Recall curve\n \'prec_at_80_recall\': Precision at 80% recall\n \'prec_at_90_recall\': Precision at 90% recall\nExamples:\n >>> predictions = [{\'prediction_text\': [\'The seller:\', \'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.\'], \'id\': \'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties\'}]\n >>> references = [{\'answers\': {\'answer_start\': [143, 49], \'text\': [\'The seller:\', \'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.\']}, \'id\': \'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties\'}]\n >>> cuad_metric = datasets.load_metric("cuad")\n >>> results = cuad_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'exact_match\': 100.0, \'f1\': 100.0, \'aupr\': 0.0, \'prec_at_80_recall\': 1.0, \'prec_at_90_recall\': 1.0}\n' @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class lowerCamelCase_ ( datasets.Metric ): def SCREAMING_SNAKE_CASE_ ( self : List[str] ): '''simple docstring''' return datasets.MetricInfo( description=_DESCRIPTION ,citation=_CITATION ,inputs_description=_KWARGS_DESCRIPTION ,features=datasets.Features( { '''predictions''': { '''id''': datasets.Value('''string''' ), '''prediction_text''': datasets.features.Sequence(datasets.Value('''string''' ) ), }, '''references''': { '''id''': datasets.Value('''string''' ), '''answers''': datasets.features.Sequence( { '''text''': datasets.Value('''string''' ), '''answer_start''': datasets.Value('''int32''' ), } ), }, } ) ,codebase_urls=['''https://www.atticusprojectai.org/cuad'''] ,reference_urls=['''https://www.atticusprojectai.org/cuad'''] ,) def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : int ,__lowerCamelCase : Optional[Any] ): '''simple docstring''' a = {prediction['id']: prediction['prediction_text'] for prediction in predictions} a = [ { 'paragraphs': [ { 'qas': [ { 'answers': [{'text': answer_text} for answer_text in ref['answers']['text']], 'id': ref['id'], } for ref in references ] } ] } ] a = evaluate(dataset=__lowerCamelCase ,predictions=__lowerCamelCase ) return score
359
def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Union[str, Any]: """simple docstring""" stooge(snake_case_, 0, len(snake_case_ ) - 1 ) return arr def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> Optional[Any]: """simple docstring""" if i >= h: return # If first element is smaller than the last then swap them if arr[i] > arr[h]: a , a = arr[h], arr[i] # If there are more than 2 elements in the array if h - i + 1 > 2: a = (int)((h - i + 1) / 3 ) # Recursively sort first 2/3 elements stooge(snake_case_, snake_case_, (h - t) ) # Recursively sort last 2/3 elements stooge(snake_case_, i + t, (snake_case_) ) # Recursively sort first 2/3 elements stooge(snake_case_, snake_case_, (h - t) ) if __name__ == "__main__": UpperCamelCase__ : Dict = input("""Enter numbers separated by a comma:\n""").strip() UpperCamelCase__ : Optional[int] = [int(item) for item in user_input.split(""",""")] print(stooge_sort(unsorted))
330
0
from ..models.auto import AutoModelForSeqaSeqLM, AutoTokenizer from .base import PipelineTool class lowerCamelCase_ ( _lowercase ): SCREAMING_SNAKE_CASE_ = 'philschmid/bart-large-cnn-samsum' SCREAMING_SNAKE_CASE_ = ( 'This is a tool that summarizes an English text. It takes an input `text` containing the text to summarize, ' 'and returns a summary of the text.' ) SCREAMING_SNAKE_CASE_ = 'summarizer' SCREAMING_SNAKE_CASE_ = AutoTokenizer SCREAMING_SNAKE_CASE_ = AutoModelForSeqaSeqLM SCREAMING_SNAKE_CASE_ = ['text'] SCREAMING_SNAKE_CASE_ = ['text'] def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ,__lowerCamelCase : Dict ): '''simple docstring''' return self.pre_processor(__UpperCamelCase ,return_tensors='''pt''' ,truncation=__UpperCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ,__lowerCamelCase : List[str] ): '''simple docstring''' return self.model.generate(**__UpperCamelCase )[0] def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : str ): '''simple docstring''' return self.pre_processor.decode(__UpperCamelCase ,skip_special_tokens=__UpperCamelCase ,clean_up_tokenization_spaces=__UpperCamelCase )
360
import json import os import re import unicodedata from json.encoder import INFINITY from typing import Any, Dict, List, Optional, Tuple, Union import numpy as np import regex from ...tokenization_utils import AddedToken, PreTrainedTokenizer from ...tokenization_utils_base import BatchEncoding from ...utils import TensorType, is_flax_available, is_tf_available, is_torch_available, logging from ...utils.generic import _is_jax, _is_numpy UpperCamelCase__ : Any = logging.get_logger(__name__) UpperCamelCase__ : Optional[Any] = { """artists_file""": """artists.json""", """lyrics_file""": """lyrics.json""", """genres_file""": """genres.json""", } UpperCamelCase__ : Union[str, Any] = { """artists_file""": { """jukebox""": """https://huggingface.co/ArthurZ/jukebox/blob/main/artists.json""", }, """genres_file""": { """jukebox""": """https://huggingface.co/ArthurZ/jukebox/blob/main/genres.json""", }, """lyrics_file""": { """jukebox""": """https://huggingface.co/ArthurZ/jukebox/blob/main/lyrics.json""", }, } UpperCamelCase__ : str = { """jukebox""": 512, } class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = VOCAB_FILES_NAMES SCREAMING_SNAKE_CASE_ = PRETRAINED_VOCAB_FILES_MAP SCREAMING_SNAKE_CASE_ = PRETRAINED_LYRIC_TOKENS_SIZES SCREAMING_SNAKE_CASE_ = ['input_ids', 'attention_mask'] def __init__( self : Optional[Any] ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : List[Any] ,__lowerCamelCase : Tuple ,__lowerCamelCase : Union[str, Any]=["v3", "v2", "v2"] ,__lowerCamelCase : List[Any]=5_12 ,__lowerCamelCase : Tuple=5 ,__lowerCamelCase : List[Any]="<|endoftext|>" ,**__lowerCamelCase : List[str] ,): '''simple docstring''' a = AddedToken(__lowerCamelCase ,lstrip=__lowerCamelCase ,rstrip=__lowerCamelCase ) if isinstance(__lowerCamelCase ,__lowerCamelCase ) else unk_token super().__init__( unk_token=__lowerCamelCase ,n_genres=__lowerCamelCase ,version=__lowerCamelCase ,max_n_lyric_tokens=__lowerCamelCase ,**__lowerCamelCase ,) a = version a = max_n_lyric_tokens a = n_genres with open(__lowerCamelCase ,encoding='''utf-8''' ) as vocab_handle: a = json.load(__lowerCamelCase ) with open(__lowerCamelCase ,encoding='''utf-8''' ) as vocab_handle: a = json.load(__lowerCamelCase ) with open(__lowerCamelCase ,encoding='''utf-8''' ) as vocab_handle: a = json.load(__lowerCamelCase ) a = r'''[^A-Za-z0-9.,:;!?\-\'\"()\[\] \t\n]+''' # In v2, we had a n_vocab=80 and in v3 we missed + and so n_vocab=79 of characters. if len(self.lyrics_encoder ) == 79: a = oov.replace(r'''\-\'''' ,r'''\-+\'''' ) a = regex.compile(__lowerCamelCase ) a = {v: k for k, v in self.artists_encoder.items()} a = {v: k for k, v in self.genres_encoder.items()} a = {v: k for k, v in self.lyrics_encoder.items()} @property def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' return len(self.artists_encoder ) + len(self.genres_encoder ) + len(self.lyrics_encoder ) def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ): '''simple docstring''' return dict(self.artists_encoder ,self.genres_encoder ,self.lyrics_encoder ) def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : Optional[int] ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : List[Any] ): '''simple docstring''' a = [self.artists_encoder.get(__lowerCamelCase ,0 ) for artist in list_artists] for genres in range(len(__lowerCamelCase ) ): a = [self.genres_encoder.get(__lowerCamelCase ,0 ) for genre in list_genres[genres]] a = list_genres[genres] + [-1] * (self.n_genres - len(list_genres[genres] )) a = [[self.lyrics_encoder.get(__lowerCamelCase ,0 ) for character in list_lyrics[0]], [], []] return artists_id, list_genres, lyric_ids def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : List[str] ): '''simple docstring''' return list(__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : List[Any] ,__lowerCamelCase : Any ,__lowerCamelCase : Optional[int] ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' a , a , a = self.prepare_for_tokenization(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ) a = self._tokenize(__lowerCamelCase ) return artist, genre, lyrics def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : str ,__lowerCamelCase : str ,__lowerCamelCase : str ,__lowerCamelCase : bool = False ): '''simple docstring''' for idx in range(len(self.version ) ): if self.version[idx] == "v3": a = artists[idx].lower() a = [genres[idx].lower()] else: a = self._normalize(artists[idx] ) + '''.v2''' a = [ self._normalize(__lowerCamelCase ) + '''.v2''' for genre in genres[idx].split('''_''' ) ] # split is for the full dictionary with combined genres if self.version[0] == "v2": a = regex.compile(r'''[^A-Za-z0-9.,:;!?\-\'\"()\[\] \t\n]+''' ) a = '''ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.,:;!?-+\'\"()[] \t\n''' a = {vocab[index]: index + 1 for index in range(len(__lowerCamelCase ) )} a = 0 a = len(__lowerCamelCase ) + 1 a = self.vocab a = {v: k for k, v in self.vocab.items()} a = '''''' else: a = regex.compile(r'''[^A-Za-z0-9.,:;!?\-+\'\"()\[\] \t\n]+''' ) a = self._run_strip_accents(__lowerCamelCase ) a = lyrics.replace('''\\''' ,'''\n''' ) a = self.out_of_vocab.sub('''''' ,__lowerCamelCase ), [], [] return artists, genres, lyrics def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : int ): '''simple docstring''' a = unicodedata.normalize('''NFD''' ,__lowerCamelCase ) a = [] for char in text: a = unicodedata.category(__lowerCamelCase ) if cat == "Mn": continue output.append(__lowerCamelCase ) return "".join(__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : str ): '''simple docstring''' a = ( [chr(__lowerCamelCase ) for i in range(ord('''a''' ) ,ord('''z''' ) + 1 )] + [chr(__lowerCamelCase ) for i in range(ord('''A''' ) ,ord('''Z''' ) + 1 )] + [chr(__lowerCamelCase ) for i in range(ord('''0''' ) ,ord('''9''' ) + 1 )] + ['''.'''] ) a = frozenset(__lowerCamelCase ) a = re.compile(r'''_+''' ) a = ''''''.join([c if c in accepted else '''_''' for c in text.lower()] ) a = pattern.sub('''_''' ,__lowerCamelCase ).strip('''_''' ) return text def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : List[str] ): '''simple docstring''' return " ".join(__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : str ,__lowerCamelCase : Optional[Union[str, TensorType]] = None ,__lowerCamelCase : bool = False ): '''simple docstring''' if not isinstance(__lowerCamelCase ,__lowerCamelCase ): a = TensorType(__lowerCamelCase ) # Get a function reference for the correct framework if tensor_type == TensorType.TENSORFLOW: if not is_tf_available(): raise ImportError( '''Unable to convert output to TensorFlow tensors format, TensorFlow is not installed.''' ) import tensorflow as tf a = tf.constant a = tf.is_tensor elif tensor_type == TensorType.PYTORCH: if not is_torch_available(): raise ImportError('''Unable to convert output to PyTorch tensors format, PyTorch is not installed.''' ) import torch a = torch.tensor a = torch.is_tensor elif tensor_type == TensorType.JAX: if not is_flax_available(): raise ImportError('''Unable to convert output to JAX tensors format, JAX is not installed.''' ) import jax.numpy as jnp # noqa: F811 a = jnp.array a = _is_jax else: a = np.asarray a = _is_numpy # Do the tensor conversion in batch try: if prepend_batch_axis: a = [inputs] if not is_tensor(__lowerCamelCase ): a = as_tensor(__lowerCamelCase ) except: # noqa E722 raise ValueError( '''Unable to create tensor, you should probably activate truncation and/or padding ''' '''with \'padding=True\' \'truncation=True\' to have batched tensors with the same length.''' ) return inputs def __call__( self : Tuple ,__lowerCamelCase : Tuple ,__lowerCamelCase : Optional[int] ,__lowerCamelCase : List[str]="" ,__lowerCamelCase : List[Any]="pt" ): '''simple docstring''' a = [0, 0, 0] a = [artist] * len(self.version ) a = [genres] * len(self.version ) a , a , a = self.tokenize(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ) a , a , a = self._convert_token_to_id(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ) a = [-INFINITY] * len(full_tokens[-1] ) a = [ self.convert_to_tensors( [input_ids + [artists_id[i]] + genres_ids[i] + full_tokens[i]] ,tensor_type=__lowerCamelCase ) for i in range(len(self.version ) ) ] return BatchEncoding({'''input_ids''': input_ids, '''attention_masks''': attention_masks} ) def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : str ,__lowerCamelCase : Optional[str] = None ): '''simple docstring''' if not os.path.isdir(__lowerCamelCase ): logger.error(F"""Vocabulary path ({save_directory}) should be a directory""" ) return a = os.path.join( __lowerCamelCase ,(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''artists_file'''] ) with open(__lowerCamelCase ,'''w''' ,encoding='''utf-8''' ) as f: f.write(json.dumps(self.artists_encoder ,ensure_ascii=__lowerCamelCase ) ) a = os.path.join( __lowerCamelCase ,(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''genres_file'''] ) with open(__lowerCamelCase ,'''w''' ,encoding='''utf-8''' ) as f: f.write(json.dumps(self.genres_encoder ,ensure_ascii=__lowerCamelCase ) ) a = os.path.join( __lowerCamelCase ,(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''lyrics_file'''] ) with open(__lowerCamelCase ,'''w''' ,encoding='''utf-8''' ) as f: f.write(json.dumps(self.lyrics_encoder ,ensure_ascii=__lowerCamelCase ) ) return (artists_file, genres_file, lyrics_file) def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : Any ,__lowerCamelCase : Any ,__lowerCamelCase : str ): '''simple docstring''' a = self.artists_decoder.get(__lowerCamelCase ) a = [self.genres_decoder.get(__lowerCamelCase ) for genre in genres_index] a = [self.lyrics_decoder.get(__lowerCamelCase ) for character in lyric_index] return artist, genres, lyrics
330
0
from sklearn.metrics import fa_score, matthews_corrcoef import datasets from .record_evaluation import evaluate as evaluate_record UpperCamelCase__ : List[Any] = """\ @article{wang2019superglue, title={SuperGLUE: A Stickier Benchmark for General-Purpose Language Understanding Systems}, author={Wang, Alex and Pruksachatkun, Yada and Nangia, Nikita and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R}, journal={arXiv preprint arXiv:1905.00537}, year={2019} } """ UpperCamelCase__ : List[str] = """\ SuperGLUE (https://super.gluebenchmark.com/) is a new benchmark styled after GLUE with a new set of more difficult language understanding tasks, improved resources, and a new public leaderboard. """ UpperCamelCase__ : Any = """ Compute SuperGLUE evaluation metric associated to each SuperGLUE dataset. Args: predictions: list of predictions to score. Depending on the SuperGlUE subset: - for 'record': list of question-answer dictionaries with the following keys: - 'idx': index of the question as specified by the dataset - 'prediction_text': the predicted answer text - for 'multirc': list of question-answer dictionaries with the following keys: - 'idx': index of the question-answer pair as specified by the dataset - 'prediction': the predicted answer label - otherwise: list of predicted labels references: list of reference labels. Depending on the SuperGLUE subset: - for 'record': list of question-answers dictionaries with the following keys: - 'idx': index of the question as specified by the dataset - 'answers': list of possible answers - otherwise: list of reference labels Returns: depending on the SuperGLUE subset: - for 'record': - 'exact_match': Exact match between answer and gold answer - 'f1': F1 score - for 'multirc': - 'exact_match': Exact match between answer and gold answer - 'f1_m': Per-question macro-F1 score - 'f1_a': Average F1 score over all answers - for 'axb': 'matthews_correlation': Matthew Correlation - for 'cb': - 'accuracy': Accuracy - 'f1': F1 score - for all others: - 'accuracy': Accuracy Examples: >>> super_glue_metric = datasets.load_metric('super_glue', 'copa') # any of [\"copa\", \"rte\", \"wic\", \"wsc\", \"wsc.fixed\", \"boolq\", \"axg\"] >>> predictions = [0, 1] >>> references = [0, 1] >>> results = super_glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'accuracy': 1.0} >>> super_glue_metric = datasets.load_metric('super_glue', 'cb') >>> predictions = [0, 1] >>> references = [0, 1] >>> results = super_glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'accuracy': 1.0, 'f1': 1.0} >>> super_glue_metric = datasets.load_metric('super_glue', 'record') >>> predictions = [{'idx': {'passage': 0, 'query': 0}, 'prediction_text': 'answer'}] >>> references = [{'idx': {'passage': 0, 'query': 0}, 'answers': ['answer', 'another_answer']}] >>> results = super_glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'exact_match': 1.0, 'f1': 1.0} >>> super_glue_metric = datasets.load_metric('super_glue', 'multirc') >>> predictions = [{'idx': {'answer': 0, 'paragraph': 0, 'question': 0}, 'prediction': 0}, {'idx': {'answer': 1, 'paragraph': 2, 'question': 3}, 'prediction': 1}] >>> references = [0, 1] >>> results = super_glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'exact_match': 1.0, 'f1_m': 1.0, 'f1_a': 1.0} >>> super_glue_metric = datasets.load_metric('super_glue', 'axb') >>> references = [0, 1] >>> predictions = [0, 1] >>> results = super_glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'matthews_correlation': 1.0} """ def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> Tuple: """simple docstring""" return float((preds == labels).mean() ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_="binary" ) -> Optional[Any]: """simple docstring""" a = simple_accuracy(snake_case_, snake_case_ ) a = float(fa_score(y_true=snake_case_, y_pred=snake_case_, average=snake_case_ ) ) return { "accuracy": acc, "f1": fa, } def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> Dict: """simple docstring""" a = {} for id_pred, label in zip(snake_case_, snake_case_ ): a = f"""{id_pred["idx"]["paragraph"]}-{id_pred["idx"]["question"]}""" a = id_pred['''prediction'''] if question_id in question_map: question_map[question_id].append((pred, label) ) else: a = [(pred, label)] a , a = [], [] for question, preds_labels in question_map.items(): a , a = zip(*snake_case_ ) a = fa_score(y_true=snake_case_, y_pred=snake_case_, average='''macro''' ) fas.append(snake_case_ ) a = int(sum(pred == label for pred, label in preds_labels ) == len(snake_case_ ) ) ems.append(snake_case_ ) a = float(sum(snake_case_ ) / len(snake_case_ ) ) a = sum(snake_case_ ) / len(snake_case_ ) a = float(fa_score(y_true=snake_case_, y_pred=[id_pred['''prediction'''] for id_pred in ids_preds] ) ) return {"exact_match": em, "f1_m": fa_m, "f1_a": fa_a} @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class lowerCamelCase_ ( datasets.Metric ): def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ): '''simple docstring''' if self.config_name not in [ "boolq", "cb", "copa", "multirc", "record", "rte", "wic", "wsc", "wsc.fixed", "axb", "axg", ]: raise KeyError( '''You should supply a configuration name selected in ''' '''["boolq", "cb", "copa", "multirc", "record", "rte", "wic", "wsc", "wsc.fixed", "axb", "axg",]''' ) return datasets.MetricInfo( description=_DESCRIPTION ,citation=_CITATION ,inputs_description=_KWARGS_DESCRIPTION ,features=datasets.Features(self._get_feature_types() ) ,codebase_urls=[] ,reference_urls=[] ,format='''numpy''' if not self.config_name == '''record''' and not self.config_name == '''multirc''' else None ,) def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' if self.config_name == "record": return { "predictions": { "idx": { "passage": datasets.Value('''int64''' ), "query": datasets.Value('''int64''' ), }, "prediction_text": datasets.Value('''string''' ), }, "references": { "idx": { "passage": datasets.Value('''int64''' ), "query": datasets.Value('''int64''' ), }, "answers": datasets.Sequence(datasets.Value('''string''' ) ), }, } elif self.config_name == "multirc": return { "predictions": { "idx": { "answer": datasets.Value('''int64''' ), "paragraph": datasets.Value('''int64''' ), "question": datasets.Value('''int64''' ), }, "prediction": datasets.Value('''int64''' ), }, "references": datasets.Value('''int64''' ), } else: return { "predictions": datasets.Value('''int64''' ), "references": datasets.Value('''int64''' ), } def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : List[Any] ,__lowerCamelCase : Optional[int] ): '''simple docstring''' if self.config_name == "axb": return {"matthews_correlation": matthews_corrcoef(UpperCAmelCase__ ,UpperCAmelCase__ )} elif self.config_name == "cb": return acc_and_fa(UpperCAmelCase__ ,UpperCAmelCase__ ,fa_avg='''macro''' ) elif self.config_name == "record": a = [ { '''qas''': [ {'''id''': ref['''idx''']['''query'''], '''answers''': [{'''text''': ans} for ans in ref['''answers''']]} for ref in references ] } ] a = {pred['''idx''']['''query''']: pred['''prediction_text'''] for pred in predictions} return evaluate_record(UpperCAmelCase__ ,UpperCAmelCase__ )[0] elif self.config_name == "multirc": return evaluate_multirc(UpperCAmelCase__ ,UpperCAmelCase__ ) elif self.config_name in ["copa", "rte", "wic", "wsc", "wsc.fixed", "boolq", "axg"]: return {"accuracy": simple_accuracy(UpperCAmelCase__ ,UpperCAmelCase__ )} else: raise KeyError( '''You should supply a configuration name selected in ''' '''["boolq", "cb", "copa", "multirc", "record", "rte", "wic", "wsc", "wsc.fixed", "axb", "axg",]''' )
361
# This script creates a super tiny model that is useful inside tests, when we just want to test that # the machinery works, without needing to the check the quality of the outcomes. # # This version creates a tiny vocab first, and then a tiny model - so the outcome is truly tiny - # all files ~60KB. As compared to taking a full-size model, reducing to the minimum its layers and # emb dimensions, but keeping the full vocab + merges files, leading to ~3MB in total for all files. # The latter is done by `fsmt-make-super-tiny-model.py`. # # It will be used then as "stas/tiny-wmt19-en-ru" from pathlib import Path import json import tempfile from transformers import FSMTTokenizer, FSMTConfig, FSMTForConditionalGeneration from transformers.models.fsmt.tokenization_fsmt import VOCAB_FILES_NAMES UpperCamelCase__ : Optional[Any] = """tiny-wmt19-en-ru""" # Build # borrowed from a test UpperCamelCase__ : Any = [ """l""", """o""", """w""", """e""", """r""", """s""", """t""", """i""", """d""", """n""", """w</w>""", """r</w>""", """t</w>""", """lo""", """low""", """er</w>""", """low</w>""", """lowest</w>""", """newer</w>""", """wider</w>""", """<unk>""", ] UpperCamelCase__ : List[Any] = dict(zip(vocab, range(len(vocab)))) UpperCamelCase__ : Any = ["""l o 123""", """lo w 1456""", """e r</w> 1789""", """"""] with tempfile.TemporaryDirectory() as tmpdirname: UpperCamelCase__ : Optional[Any] = Path(tmpdirname) UpperCamelCase__ : Tuple = build_dir / VOCAB_FILES_NAMES["""src_vocab_file"""] UpperCamelCase__ : int = build_dir / VOCAB_FILES_NAMES["""tgt_vocab_file"""] UpperCamelCase__ : Union[str, Any] = build_dir / VOCAB_FILES_NAMES["""merges_file"""] with open(src_vocab_file, """w""") as fp: fp.write(json.dumps(vocab_tokens)) with open(tgt_vocab_file, """w""") as fp: fp.write(json.dumps(vocab_tokens)) with open(merges_file, """w""") as fp: fp.write("""\n""".join(merges)) UpperCamelCase__ : Dict = FSMTTokenizer( langs=["""en""", """ru"""], src_vocab_size=len(vocab), tgt_vocab_size=len(vocab), src_vocab_file=src_vocab_file, tgt_vocab_file=tgt_vocab_file, merges_file=merges_file, ) UpperCamelCase__ : Union[str, Any] = FSMTConfig( langs=["""ru""", """en"""], src_vocab_size=1_000, tgt_vocab_size=1_000, d_model=4, encoder_layers=1, decoder_layers=1, encoder_ffn_dim=4, decoder_ffn_dim=4, encoder_attention_heads=1, decoder_attention_heads=1, ) UpperCamelCase__ : Union[str, Any] = FSMTForConditionalGeneration(config) print(F"num of params {tiny_model.num_parameters()}") # Test UpperCamelCase__ : List[str] = tokenizer(["""Making tiny model"""], return_tensors="""pt""") UpperCamelCase__ : Tuple = tiny_model(**batch) print("""test output:""", len(outputs.logits[0])) # Save tiny_model.half() # makes it smaller tiny_model.save_pretrained(mname_tiny) tokenizer.save_pretrained(mname_tiny) print(F"Generated {mname_tiny}") # Upload # transformers-cli upload tiny-wmt19-en-ru
330
0
import re def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> bool: """simple docstring""" a = re.compile( r'''^(?:0|94|\+94|0{2}94)''' r'''7(0|1|2|4|5|6|7|8)''' r'''(-| |)''' r'''\d{7}$''' ) return bool(re.search(__lowerCAmelCase, __lowerCAmelCase ) ) if __name__ == "__main__": UpperCamelCase__ : Optional[int] = "0094702343221" print(is_sri_lankan_phone_number(phone))
362
import inspect import os import torch from transformers import AutoModel from transformers.testing_utils import mockenv_context from transformers.trainer_utils import set_seed import accelerate from accelerate.accelerator import Accelerator from accelerate.state import AcceleratorState from accelerate.test_utils.testing import ( AccelerateTestCase, TempDirTestCase, execute_subprocess_async, require_cuda, require_fsdp, require_multi_gpu, slow, ) from accelerate.utils.constants import ( FSDP_AUTO_WRAP_POLICY, FSDP_BACKWARD_PREFETCH, FSDP_SHARDING_STRATEGY, FSDP_STATE_DICT_TYPE, ) from accelerate.utils.dataclasses import FullyShardedDataParallelPlugin from accelerate.utils.other import patch_environment set_seed(42) UpperCamelCase__ : Optional[Any] = """bert-base-cased""" UpperCamelCase__ : int = """fp16""" UpperCamelCase__ : str = """bf16""" UpperCamelCase__ : List[Any] = [FPaa, BFaa] @require_fsdp @require_cuda class lowerCamelCase_ ( a_ ): def SCREAMING_SNAKE_CASE_ ( self : int ): '''simple docstring''' super().setUp() a = dict( ACCELERATE_USE_FSDP='''true''' ,MASTER_ADDR='''localhost''' ,MASTER_PORT='''10999''' ,RANK='''0''' ,LOCAL_RANK='''0''' ,WORLD_SIZE='''1''' ,) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import ShardingStrategy for i, strategy in enumerate(__lowerCamelCase ): a = self.dist_env.copy() a = F"""{i + 1}""" a = strategy with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() self.assertEqual(fsdp_plugin.sharding_strategy ,ShardingStrategy(i + 1 ) ) def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import BackwardPrefetch for i, prefetch_policy in enumerate(__lowerCamelCase ): a = self.dist_env.copy() a = prefetch_policy with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() if prefetch_policy == "NO_PREFETCH": self.assertIsNone(fsdp_plugin.backward_prefetch ) else: self.assertEqual(fsdp_plugin.backward_prefetch ,BackwardPrefetch(i + 1 ) ) def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType for i, state_dict_type in enumerate(__lowerCamelCase ): a = self.dist_env.copy() a = state_dict_type with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() self.assertEqual(fsdp_plugin.state_dict_type ,StateDictType(i + 1 ) ) if state_dict_type == "FULL_STATE_DICT": self.assertTrue(fsdp_plugin.state_dict_config.offload_to_cpu ) self.assertTrue(fsdp_plugin.state_dict_config.ranka_only ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ): '''simple docstring''' a = AutoModel.from_pretrained(__lowerCamelCase ) for policy in FSDP_AUTO_WRAP_POLICY: a = self.dist_env.copy() a = policy if policy == "TRANSFORMER_BASED_WRAP": a = '''BertLayer''' elif policy == "SIZE_BASED_WRAP": a = '''2000''' with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() fsdp_plugin.set_auto_wrap_policy(__lowerCamelCase ) if policy == "NO_WRAP": self.assertIsNone(fsdp_plugin.auto_wrap_policy ) else: self.assertIsNotNone(fsdp_plugin.auto_wrap_policy ) a = self.dist_env.copy() a = '''TRANSFORMER_BASED_WRAP''' a = '''T5Layer''' with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() with self.assertRaises(__lowerCamelCase ) as cm: fsdp_plugin.set_auto_wrap_policy(__lowerCamelCase ) self.assertTrue('''Could not find the transformer layer class to wrap in the model.''' in str(cm.exception ) ) a = self.dist_env.copy() a = '''SIZE_BASED_WRAP''' a = '''0''' with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() fsdp_plugin.set_auto_wrap_policy(__lowerCamelCase ) self.assertIsNone(fsdp_plugin.auto_wrap_policy ) def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import MixedPrecision from torch.distributed.fsdp.sharded_grad_scaler import ShardedGradScaler for mp_dtype in dtypes: a = self.dist_env.copy() a = mp_dtype with mockenv_context(**__lowerCamelCase ): a = Accelerator() if mp_dtype == "fp16": a = torch.floataa elif mp_dtype == "bf16": a = torch.bfloataa a = MixedPrecision(param_dtype=__lowerCamelCase ,reduce_dtype=__lowerCamelCase ,buffer_dtype=__lowerCamelCase ) self.assertEqual(accelerator.state.fsdp_plugin.mixed_precision_policy ,__lowerCamelCase ) if mp_dtype == FPaa: self.assertTrue(isinstance(accelerator.scaler ,__lowerCamelCase ) ) elif mp_dtype == BFaa: self.assertIsNone(accelerator.scaler ) AcceleratorState._reset_state(__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import CPUOffload for flag in [True, False]: a = self.dist_env.copy() a = str(__lowerCamelCase ).lower() with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() self.assertEqual(fsdp_plugin.cpu_offload ,CPUOffload(offload_params=__lowerCamelCase ) ) @require_fsdp @require_multi_gpu @slow class lowerCamelCase_ ( a_ ): def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' super().setUp() a = 0.82 a = [ '''fsdp_shard_grad_op_transformer_based_wrap''', '''fsdp_full_shard_transformer_based_wrap''', ] a = { '''multi_gpu_fp16''': 32_00, '''fsdp_shard_grad_op_transformer_based_wrap_fp16''': 20_00, '''fsdp_full_shard_transformer_based_wrap_fp16''': 19_00, # Disabling below test as it overwhelms the RAM memory usage # on CI self-hosted runner leading to tests getting killed. # "fsdp_full_shard_cpu_offload_transformer_based_wrap_fp32": 1500, # fp16 was leading to indefinite hang } a = 1_60 a = 1_60 a = inspect.getfile(accelerate.test_utils ) a = os.path.sep.join(mod_file.split(os.path.sep )[:-1] + ['''scripts''', '''external_deps'''] ) def SCREAMING_SNAKE_CASE_ ( self : List[str] ): '''simple docstring''' a = os.path.join(self.test_scripts_folder ,'''test_performance.py''' ) a = ['''accelerate''', '''launch''', '''--num_processes=2''', '''--num_machines=1''', '''--machine_rank=0''', '''--use_fsdp'''] for config in self.performance_configs: a = cmd.copy() for i, strategy in enumerate(__lowerCamelCase ): if strategy.lower() in config: cmd_config.append(F"""--fsdp_sharding_strategy={i+1}""" ) break if "fp32" in config: cmd_config.append('''--mixed_precision=no''' ) else: cmd_config.append('''--mixed_precision=fp16''' ) if "cpu_offload" in config: cmd_config.append('''--fsdp_offload_params=True''' ) for policy in FSDP_AUTO_WRAP_POLICY: if policy.lower() in config: cmd_config.append(F"""--fsdp_auto_wrap_policy={policy}""" ) break if policy == "TRANSFORMER_BASED_WRAP": cmd_config.append('''--fsdp_transformer_layer_cls_to_wrap=BertLayer''' ) elif policy == "SIZE_BASED_WRAP": cmd_config.append('''--fsdp_min_num_params=2000''' ) cmd_config.extend( [ self.test_file_path, F"""--output_dir={self.tmpdir}""", F"""--performance_lower_bound={self.performance_lower_bound}""", ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(__lowerCamelCase ,env=os.environ.copy() ) def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' a = os.path.join(self.test_scripts_folder ,'''test_checkpointing.py''' ) a = [ '''accelerate''', '''launch''', '''--num_processes=2''', '''--num_machines=1''', '''--machine_rank=0''', '''--use_fsdp''', '''--mixed_precision=fp16''', '''--fsdp_transformer_layer_cls_to_wrap=BertLayer''', ] for i, strategy in enumerate(__lowerCamelCase ): a = cmd.copy() cmd_config.append(F"""--fsdp_sharding_strategy={i+1}""" ) if strategy != "FULL_SHARD": continue a = len(__lowerCamelCase ) for state_dict_type in FSDP_STATE_DICT_TYPE: a = cmd_config[:state_dict_config_index] cmd_config.append(F"""--fsdp_state_dict_type={state_dict_type}""" ) cmd_config.extend( [ self.test_file_path, F"""--output_dir={self.tmpdir}""", '''--partial_train_epoch=1''', ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(__lowerCamelCase ,env=os.environ.copy() ) a = cmd_config[:-1] a = os.path.join(self.tmpdir ,'''epoch_0''' ) cmd_config.extend( [ F"""--resume_from_checkpoint={resume_from_checkpoint}""", ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(__lowerCamelCase ,env=os.environ.copy() ) def SCREAMING_SNAKE_CASE_ ( self : int ): '''simple docstring''' a = os.path.join(self.test_scripts_folder ,'''test_peak_memory_usage.py''' ) a = [ '''accelerate''', '''launch''', '''--num_processes=2''', '''--num_machines=1''', '''--machine_rank=0''', ] for spec, peak_mem_upper_bound in self.peak_memory_usage_upper_bound.items(): a = cmd.copy() if "fp16" in spec: cmd_config.extend(['''--mixed_precision=fp16'''] ) else: cmd_config.extend(['''--mixed_precision=no'''] ) if "multi_gpu" in spec: continue else: cmd_config.extend(['''--use_fsdp'''] ) for i, strategy in enumerate(__lowerCamelCase ): if strategy.lower() in spec: cmd_config.append(F"""--fsdp_sharding_strategy={i+1}""" ) break if "cpu_offload" in spec: cmd_config.append('''--fsdp_offload_params=True''' ) for policy in FSDP_AUTO_WRAP_POLICY: if policy.lower() in spec: cmd_config.append(F"""--fsdp_auto_wrap_policy={policy}""" ) break if policy == "TRANSFORMER_BASED_WRAP": cmd_config.append('''--fsdp_transformer_layer_cls_to_wrap=BertLayer''' ) elif policy == "SIZE_BASED_WRAP": cmd_config.append('''--fsdp_min_num_params=2000''' ) cmd_config.extend( [ self.test_file_path, F"""--output_dir={self.tmpdir}""", F"""--peak_memory_upper_bound={peak_mem_upper_bound}""", F"""--n_train={self.n_train}""", F"""--n_val={self.n_val}""", ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(__lowerCamelCase ,env=os.environ.copy() )
330
0
"""simple docstring""" import os import string import sys UpperCamelCase__ : Optional[int] = 1 << 8 UpperCamelCase__ : List[Any] = { 'tab': ord("""\t"""), 'newline': ord("""\r"""), 'esc': 27, 'up': 65 + ARROW_KEY_FLAG, 'down': 66 + ARROW_KEY_FLAG, 'right': 67 + ARROW_KEY_FLAG, 'left': 68 + ARROW_KEY_FLAG, 'mod_int': 91, 'undefined': sys.maxsize, 'interrupt': 3, 'insert': 50, 'delete': 51, 'pg_up': 53, 'pg_down': 54, } UpperCamelCase__ : Any = KEYMAP['up'] UpperCamelCase__ : str = KEYMAP['left'] if sys.platform == "win32": UpperCamelCase__ : Union[str, Any] = [] UpperCamelCase__ : Union[str, Any] = { b'\xe0H': KEYMAP['up'] - ARROW_KEY_FLAG, b'\x00H': KEYMAP['up'] - ARROW_KEY_FLAG, b'\xe0P': KEYMAP['down'] - ARROW_KEY_FLAG, b'\x00P': KEYMAP['down'] - ARROW_KEY_FLAG, b'\xe0M': KEYMAP['right'] - ARROW_KEY_FLAG, b'\x00M': KEYMAP['right'] - ARROW_KEY_FLAG, b'\xe0K': KEYMAP['left'] - ARROW_KEY_FLAG, b'\x00K': KEYMAP['left'] - ARROW_KEY_FLAG, } for i in range(10): UpperCamelCase__ : str = ord(str(i)) def SCREAMING_SNAKE_CASE__ ( ) -> Union[str, Any]: """simple docstring""" if os.name == "nt": import msvcrt a = '''mbcs''' # Flush the keyboard buffer while msvcrt.kbhit(): msvcrt.getch() if len(lowercase__ ) == 0: # Read the keystroke a = msvcrt.getch() # If it is a prefix char, get second part if ch in (b"\x00", b"\xe0"): a = ch + msvcrt.getch() # Translate actual Win chars to bullet char types try: a = chr(WIN_KEYMAP[cha] ) WIN_CH_BUFFER.append(chr(KEYMAP['''mod_int'''] ) ) WIN_CH_BUFFER.append(lowercase__ ) if ord(lowercase__ ) in ( KEYMAP["insert"] - 1 << 9, KEYMAP["delete"] - 1 << 9, KEYMAP["pg_up"] - 1 << 9, KEYMAP["pg_down"] - 1 << 9, ): WIN_CH_BUFFER.append(chr(1_2_6 ) ) a = chr(KEYMAP['''esc'''] ) except KeyError: a = cha[1] else: a = ch.decode(lowercase__ ) else: a = WIN_CH_BUFFER.pop(0 ) elif os.name == "posix": import termios import tty a = sys.stdin.fileno() a = termios.tcgetattr(lowercase__ ) try: tty.setraw(lowercase__ ) a = sys.stdin.read(1 ) finally: termios.tcsetattr(lowercase__, termios.TCSADRAIN, lowercase__ ) return ch def SCREAMING_SNAKE_CASE__ ( ) -> List[Any]: """simple docstring""" a = get_raw_chars() if ord(lowercase__ ) in [KEYMAP["interrupt"], KEYMAP["newline"]]: return char elif ord(lowercase__ ) == KEYMAP["esc"]: a = get_raw_chars() if ord(lowercase__ ) == KEYMAP["mod_int"]: a = get_raw_chars() if ord(lowercase__ ) >= KEYMAP["arrow_begin"] - ARROW_KEY_FLAG and ord(lowercase__ ) <= KEYMAP["arrow_end"] - ARROW_KEY_FLAG: return chr(ord(lowercase__ ) + ARROW_KEY_FLAG ) else: return KEYMAP["undefined"] else: return get_raw_chars() else: if char in string.printable: return char else: return KEYMAP["undefined"]
363
from __future__ import annotations import os from collections.abc import Mapping UpperCamelCase__ : Any = tuple[int, int] class lowerCamelCase_ : def __init__( self : Optional[Any] ,__lowerCamelCase : set[int] ,__lowerCamelCase : Mapping[EdgeT, int] ): '''simple docstring''' a = vertices a = { (min(__lowerCamelCase ), max(__lowerCamelCase )): weight for edge, weight in edges.items() } def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : EdgeT ,__lowerCamelCase : int ): '''simple docstring''' self.vertices.add(edge[0] ) self.vertices.add(edge[1] ) a = weight def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' a = Graph({min(self.vertices )} ,{} ) a = 42 a = 42 a = 42 a = 42 while len(subgraph.vertices ) < len(self.vertices ): a = max(self.edges.values() ) + 1 for edge, weight in self.edges.items(): if (edge[0] in subgraph.vertices) ^ (edge[1] in subgraph.vertices): if weight < min_weight: a = edge a = weight subgraph.add_edge(__lowerCamelCase ,__lowerCamelCase ) return subgraph def SCREAMING_SNAKE_CASE__ ( snake_case_ = "p107_network.txt" ) -> int: """simple docstring""" a = os.path.abspath(os.path.dirname(snake_case_ ) ) a = os.path.join(snake_case_, snake_case_ ) a = {} a = 42 a = 42 a = 42 with open(snake_case_ ) as f: a = f.read().strip().split('''\n''' ) a = [line.split(''',''' ) for line in data] for edgea in range(1, len(snake_case_ ) ): for edgea in range(snake_case_ ): if adjaceny_matrix[edgea][edgea] != "-": a = int(adjaceny_matrix[edgea][edgea] ) a = Graph(set(range(len(snake_case_ ) ) ), snake_case_ ) a = graph.prims_algorithm() a = sum(graph.edges.values() ) a = sum(subgraph.edges.values() ) return initial_total - optimal_total if __name__ == "__main__": print(F"{solution() = }")
330
0
from ...configuration_utils import PretrainedConfig from ...utils import logging from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices UpperCamelCase__ : List[Any] = logging.get_logger(__name__) UpperCamelCase__ : Union[str, Any] = { 'shi-labs/dinat-mini-in1k-224': 'https://huggingface.co/shi-labs/dinat-mini-in1k-224/resolve/main/config.json', # See all Dinat models at https://huggingface.co/models?filter=dinat } class lowerCamelCase_ ( __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): SCREAMING_SNAKE_CASE_ = 'dinat' SCREAMING_SNAKE_CASE_ = { 'num_attention_heads': 'num_heads', 'num_hidden_layers': 'num_layers', } def __init__( self : str ,__lowerCamelCase : str=4 ,__lowerCamelCase : Any=3 ,__lowerCamelCase : str=64 ,__lowerCamelCase : int=[3, 4, 6, 5] ,__lowerCamelCase : Union[str, Any]=[2, 4, 8, 16] ,__lowerCamelCase : Optional[int]=7 ,__lowerCamelCase : int=[[1, 8, 1], [1, 4, 1, 4], [1, 2, 1, 2, 1, 2], [1, 1, 1, 1, 1]] ,__lowerCamelCase : Any=3.0 ,__lowerCamelCase : int=True ,__lowerCamelCase : List[str]=0.0 ,__lowerCamelCase : Optional[int]=0.0 ,__lowerCamelCase : int=0.1 ,__lowerCamelCase : str="gelu" ,__lowerCamelCase : Optional[Any]=0.02 ,__lowerCamelCase : Dict=1e-5 ,__lowerCamelCase : Union[str, Any]=0.0 ,__lowerCamelCase : Dict=None ,__lowerCamelCase : Optional[Any]=None ,**__lowerCamelCase : int ,): '''simple docstring''' super().__init__(**_SCREAMING_SNAKE_CASE ) a = patch_size a = num_channels a = embed_dim a = depths a = len(_SCREAMING_SNAKE_CASE ) a = num_heads a = kernel_size a = dilations a = mlp_ratio a = qkv_bias a = hidden_dropout_prob a = attention_probs_dropout_prob a = drop_path_rate a = hidden_act a = layer_norm_eps a = initializer_range # we set the hidden_size attribute in order to make Dinat work with VisionEncoderDecoderModel # this indicates the channel dimension after the last stage of the model a = int(embed_dim * 2 ** (len(_SCREAMING_SNAKE_CASE ) - 1) ) a = layer_scale_init_value a = ["stem"] + [F"""stage{idx}""" for idx in range(1 ,len(_SCREAMING_SNAKE_CASE ) + 1 )] a = get_aligned_output_features_output_indices( out_features=_SCREAMING_SNAKE_CASE ,out_indices=_SCREAMING_SNAKE_CASE ,stage_names=self.stage_names )
364
from typing import Optional, Tuple, Union import tensorflow as tf from ...activations_tf import ACTaFN from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward from ...modeling_tf_outputs import ( TFBaseModelOutputWithNoAttention, TFBaseModelOutputWithPoolingAndNoAttention, TFSequenceClassifierOutput, ) from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs from ...tf_utils import shape_list from ...utils import logging from .configuration_regnet import RegNetConfig UpperCamelCase__ : List[Any] = logging.get_logger(__name__) # General docstring UpperCamelCase__ : List[Any] = """RegNetConfig""" # Base docstring UpperCamelCase__ : Dict = """facebook/regnet-y-040""" UpperCamelCase__ : int = [1, 1_088, 7, 7] # Image classification docstring UpperCamelCase__ : Optional[Any] = """facebook/regnet-y-040""" UpperCamelCase__ : Dict = """tabby, tabby cat""" UpperCamelCase__ : Dict = [ """facebook/regnet-y-040""", # See all regnet models at https://huggingface.co/models?filter=regnet ] class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : List[str] ,__lowerCamelCase : int ,__lowerCamelCase : int = 3 ,__lowerCamelCase : int = 1 ,__lowerCamelCase : int = 1 ,__lowerCamelCase : Optional[str] = "relu" ,**__lowerCamelCase : str ,): '''simple docstring''' super().__init__(**__lowerCamelCase ) # The padding and conv has been verified in # https://colab.research.google.com/gist/sayakpaul/854bc10eeaf21c9ee2119e0b9f3841a7/scratchpad.ipynb a = tf.keras.layers.ZeroPaddingaD(padding=kernel_size // 2 ) a = tf.keras.layers.ConvaD( filters=__lowerCamelCase ,kernel_size=__lowerCamelCase ,strides=__lowerCamelCase ,padding='''VALID''' ,groups=__lowerCamelCase ,use_bias=__lowerCamelCase ,name='''convolution''' ,) a = tf.keras.layers.BatchNormalization(epsilon=1e-5 ,momentum=0.9 ,name='''normalization''' ) a = ACTaFN[activation] if activation is not None else tf.identity def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : List[str] ): '''simple docstring''' a = self.convolution(self.padding(__lowerCamelCase ) ) a = self.normalization(__lowerCamelCase ) a = self.activation(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Any ,__lowerCamelCase : RegNetConfig ,**__lowerCamelCase : List[Any] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = config.num_channels a = TFRegNetConvLayer( out_channels=config.embedding_size ,kernel_size=3 ,stride=2 ,activation=config.hidden_act ,name='''embedder''' ,) def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : Optional[Any] ): '''simple docstring''' a = shape_list(__lowerCamelCase )[1] if tf.executing_eagerly() and 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.''' ) # When running on CPU, `tf.keras.layers.Conv2D` doesn't support `NCHW` format. # So change the input format from `NCHW` to `NHWC`. # shape = (batch_size, in_height, in_width, in_channels=num_channels) a = tf.transpose(__lowerCamelCase ,perm=(0, 2, 3, 1) ) a = self.embedder(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : str ,__lowerCamelCase : int ,__lowerCamelCase : int = 2 ,**__lowerCamelCase : Tuple ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = tf.keras.layers.ConvaD( filters=__lowerCamelCase ,kernel_size=1 ,strides=__lowerCamelCase ,use_bias=__lowerCamelCase ,name='''convolution''' ) a = tf.keras.layers.BatchNormalization(epsilon=1e-5 ,momentum=0.9 ,name='''normalization''' ) def SCREAMING_SNAKE_CASE_ ( self : Dict ,__lowerCamelCase : tf.Tensor ,__lowerCamelCase : bool = False ): '''simple docstring''' return self.normalization(self.convolution(__lowerCamelCase ) ,training=__lowerCamelCase ) class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : List[Any] ,__lowerCamelCase : int ,__lowerCamelCase : int ,**__lowerCamelCase : str ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = tf.keras.layers.GlobalAveragePoolingaD(keepdims=__lowerCamelCase ,name='''pooler''' ) a = [ tf.keras.layers.ConvaD(filters=__lowerCamelCase ,kernel_size=1 ,activation='''relu''' ,name='''attention.0''' ), tf.keras.layers.ConvaD(filters=__lowerCamelCase ,kernel_size=1 ,activation='''sigmoid''' ,name='''attention.2''' ), ] def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : Optional[Any] ): '''simple docstring''' a = self.pooler(__lowerCamelCase ) for layer_module in self.attention: a = layer_module(__lowerCamelCase ) a = hidden_state * pooled return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Union[str, Any] ,__lowerCamelCase : RegNetConfig ,__lowerCamelCase : int ,__lowerCamelCase : int ,__lowerCamelCase : int = 1 ,**__lowerCamelCase : Dict ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = in_channels != out_channels or stride != 1 a = max(1 ,out_channels // config.groups_width ) a = ( TFRegNetShortCut(__lowerCamelCase ,stride=__lowerCamelCase ,name='''shortcut''' ) if should_apply_shortcut else tf.keras.layers.Activation('''linear''' ,name='''shortcut''' ) ) # `self.layers` instead of `self.layer` because that is a reserved argument. a = [ TFRegNetConvLayer(__lowerCamelCase ,kernel_size=1 ,activation=config.hidden_act ,name='''layer.0''' ), TFRegNetConvLayer( __lowerCamelCase ,stride=__lowerCamelCase ,groups=__lowerCamelCase ,activation=config.hidden_act ,name='''layer.1''' ), TFRegNetConvLayer(__lowerCamelCase ,kernel_size=1 ,activation=__lowerCamelCase ,name='''layer.2''' ), ] a = ACTaFN[config.hidden_act] def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = hidden_state for layer_module in self.layers: a = layer_module(__lowerCamelCase ) a = self.shortcut(__lowerCamelCase ) hidden_state += residual a = self.activation(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Dict ,__lowerCamelCase : RegNetConfig ,__lowerCamelCase : int ,__lowerCamelCase : int ,__lowerCamelCase : int = 1 ,**__lowerCamelCase : List[str] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = in_channels != out_channels or stride != 1 a = max(1 ,out_channels // config.groups_width ) a = ( TFRegNetShortCut(__lowerCamelCase ,stride=__lowerCamelCase ,name='''shortcut''' ) if should_apply_shortcut else tf.keras.layers.Activation('''linear''' ,name='''shortcut''' ) ) a = [ TFRegNetConvLayer(__lowerCamelCase ,kernel_size=1 ,activation=config.hidden_act ,name='''layer.0''' ), TFRegNetConvLayer( __lowerCamelCase ,stride=__lowerCamelCase ,groups=__lowerCamelCase ,activation=config.hidden_act ,name='''layer.1''' ), TFRegNetSELayer(__lowerCamelCase ,reduced_channels=int(round(in_channels / 4 ) ) ,name='''layer.2''' ), TFRegNetConvLayer(__lowerCamelCase ,kernel_size=1 ,activation=__lowerCamelCase ,name='''layer.3''' ), ] a = ACTaFN[config.hidden_act] def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ,__lowerCamelCase : str ): '''simple docstring''' a = hidden_state for layer_module in self.layers: a = layer_module(__lowerCamelCase ) a = self.shortcut(__lowerCamelCase ) hidden_state += residual a = self.activation(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Optional[int] ,__lowerCamelCase : RegNetConfig ,__lowerCamelCase : int ,__lowerCamelCase : int ,__lowerCamelCase : int = 2 ,__lowerCamelCase : int = 2 ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = TFRegNetXLayer if config.layer_type == '''x''' else TFRegNetYLayer a = [ # downsampling is done in the first layer with stride of 2 layer(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ,stride=__lowerCamelCase ,name='''layers.0''' ), *[layer(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ,name=F"""layers.{i+1}""" ) for i in range(depth - 1 )], ] def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : int ): '''simple docstring''' for layer_module in self.layers: a = layer_module(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Union[str, Any] ,__lowerCamelCase : RegNetConfig ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = [] # based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input self.stages.append( TFRegNetStage( __lowerCamelCase ,config.embedding_size ,config.hidden_sizes[0] ,stride=2 if config.downsample_in_first_stage else 1 ,depth=config.depths[0] ,name='''stages.0''' ,) ) a = zip(config.hidden_sizes ,config.hidden_sizes[1:] ) for i, ((in_channels, out_channels), depth) in enumerate(zip(__lowerCamelCase ,config.depths[1:] ) ): self.stages.append(TFRegNetStage(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ,depth=__lowerCamelCase ,name=F"""stages.{i+1}""" ) ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : tf.Tensor ,__lowerCamelCase : bool = False ,__lowerCamelCase : bool = True ): '''simple docstring''' 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(__lowerCamelCase ) 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 TFBaseModelOutputWithNoAttention(last_hidden_state=__lowerCamelCase ,hidden_states=__lowerCamelCase ) @keras_serializable class lowerCamelCase_ ( tf.keras.layers.Layer ): SCREAMING_SNAKE_CASE_ = RegNetConfig def __init__( self : Dict ,__lowerCamelCase : Optional[int] ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = config a = TFRegNetEmbeddings(__lowerCamelCase ,name='''embedder''' ) a = TFRegNetEncoder(__lowerCamelCase ,name='''encoder''' ) a = tf.keras.layers.GlobalAveragePoolingaD(keepdims=__lowerCamelCase ,name='''pooler''' ) @unpack_inputs def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : tf.Tensor ,__lowerCamelCase : Optional[bool] = None ,__lowerCamelCase : Optional[bool] = None ,__lowerCamelCase : bool = False ,): '''simple docstring''' a = ( output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states ) a = return_dict if return_dict is not None else self.config.use_return_dict a = self.embedder(__lowerCamelCase ,training=__lowerCamelCase ) a = self.encoder( __lowerCamelCase ,output_hidden_states=__lowerCamelCase ,return_dict=__lowerCamelCase ,training=__lowerCamelCase ) a = encoder_outputs[0] a = self.pooler(__lowerCamelCase ) # Change to NCHW output format have uniformity in the modules a = tf.transpose(__lowerCamelCase ,perm=(0, 3, 1, 2) ) a = tf.transpose(__lowerCamelCase ,perm=(0, 3, 1, 2) ) # Change the other hidden state outputs to NCHW as well if output_hidden_states: a = tuple([tf.transpose(__lowerCamelCase ,perm=(0, 3, 1, 2) ) for h in encoder_outputs[1]] ) if not return_dict: return (last_hidden_state, pooled_output) + encoder_outputs[1:] return TFBaseModelOutputWithPoolingAndNoAttention( last_hidden_state=__lowerCamelCase ,pooler_output=__lowerCamelCase ,hidden_states=hidden_states if output_hidden_states else encoder_outputs.hidden_states ,) class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = RegNetConfig SCREAMING_SNAKE_CASE_ = 'regnet' SCREAMING_SNAKE_CASE_ = 'pixel_values' @property def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 2_24, 2_24) ,dtype=tf.floataa )} UpperCamelCase__ : Union[str, Any] = R""" Parameters: This model is a Tensorflow [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a regular Tensorflow Module and refer to the Tensorflow documentation for all matter related to general usage and behavior. config ([`RegNetConfig`]): 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 [`~TFPreTrainedModel.from_pretrained`] method to load the model weights. """ UpperCamelCase__ : List[str] = R""" Args: pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`): Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See [`ConveNextImageProcessor.__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 RegNet model outputting raw features without any specific head on top.' , a_ , ) class lowerCamelCase_ ( a_ ): def __init__( self : Optional[int] ,__lowerCamelCase : RegNetConfig ,*__lowerCamelCase : int ,**__lowerCamelCase : Union[str, Any] ): '''simple docstring''' super().__init__(__lowerCamelCase ,*__lowerCamelCase ,**__lowerCamelCase ) a = TFRegNetMainLayer(__lowerCamelCase ,name='''regnet''' ) @unpack_inputs @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 SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : tf.Tensor ,__lowerCamelCase : Optional[bool] = None ,__lowerCamelCase : Optional[bool] = None ,__lowerCamelCase : List[str]=False ,): '''simple docstring''' a = ( output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states ) a = return_dict if return_dict is not None else self.config.use_return_dict a = self.regnet( pixel_values=__lowerCamelCase ,output_hidden_states=__lowerCamelCase ,return_dict=__lowerCamelCase ,training=__lowerCamelCase ,) if not return_dict: return (outputs[0],) + outputs[1:] return TFBaseModelOutputWithPoolingAndNoAttention( last_hidden_state=outputs.last_hidden_state ,pooler_output=outputs.pooler_output ,hidden_states=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 ' , a_ , ) class lowerCamelCase_ ( a_ , a_ ): def __init__( self : Optional[int] ,__lowerCamelCase : RegNetConfig ,*__lowerCamelCase : str ,**__lowerCamelCase : Any ): '''simple docstring''' super().__init__(__lowerCamelCase ,*__lowerCamelCase ,**__lowerCamelCase ) a = config.num_labels a = TFRegNetMainLayer(__lowerCamelCase ,name='''regnet''' ) # classification head a = [ tf.keras.layers.Flatten(), tf.keras.layers.Dense(config.num_labels ,name='''classifier.1''' ) if config.num_labels > 0 else tf.identity, ] @unpack_inputs @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 SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : tf.Tensor = None ,__lowerCamelCase : tf.Tensor = None ,__lowerCamelCase : bool = None ,__lowerCamelCase : bool = None ,__lowerCamelCase : Dict=False ,): '''simple docstring''' a = ( output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states ) a = return_dict if return_dict is not None else self.config.use_return_dict a = self.regnet( __lowerCamelCase ,output_hidden_states=__lowerCamelCase ,return_dict=__lowerCamelCase ,training=__lowerCamelCase ) a = outputs.pooler_output if return_dict else outputs[1] a = self.classifier[0](__lowerCamelCase ) a = self.classifier[1](__lowerCamelCase ) a = None if labels is None else self.hf_compute_loss(labels=__lowerCamelCase ,logits=__lowerCamelCase ) if not return_dict: a = (logits,) + outputs[2:] return ((loss,) + output) if loss is not None else output return TFSequenceClassifierOutput(loss=__lowerCamelCase ,logits=__lowerCamelCase ,hidden_states=outputs.hidden_states )
330
0
import os from shutil import copyfile from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import AddedToken, BatchEncoding, PreTrainedTokenizer from ...utils import logging _A : List[str] = logging.get_logger(__name__) _A : int = """▁""" _A : Union[str, Any] = {"""vocab_file""": """sentencepiece.bpe.model"""} _A : int = { """vocab_file""": { """facebook/nllb-200-distilled-600M""": ( """https://huggingface.co/facebook/nllb-200-distilled-600M/blob/main/sentencepiece.bpe.model""" ), } } _A : Union[str, Any] = { """facebook/nllb-200-distilled-600M""": 1_024, } # fmt: off _A : List[Any] = ["""ace_Arab""", """ace_Latn""", """acm_Arab""", """acq_Arab""", """aeb_Arab""", """afr_Latn""", """ajp_Arab""", """aka_Latn""", """amh_Ethi""", """apc_Arab""", """arb_Arab""", """ars_Arab""", """ary_Arab""", """arz_Arab""", """asm_Beng""", """ast_Latn""", """awa_Deva""", """ayr_Latn""", """azb_Arab""", """azj_Latn""", """bak_Cyrl""", """bam_Latn""", """ban_Latn""", """bel_Cyrl""", """bem_Latn""", """ben_Beng""", """bho_Deva""", """bjn_Arab""", """bjn_Latn""", """bod_Tibt""", """bos_Latn""", """bug_Latn""", """bul_Cyrl""", """cat_Latn""", """ceb_Latn""", """ces_Latn""", """cjk_Latn""", """ckb_Arab""", """crh_Latn""", """cym_Latn""", """dan_Latn""", """deu_Latn""", """dik_Latn""", """dyu_Latn""", """dzo_Tibt""", """ell_Grek""", """eng_Latn""", """epo_Latn""", """est_Latn""", """eus_Latn""", """ewe_Latn""", """fao_Latn""", """pes_Arab""", """fij_Latn""", """fin_Latn""", """fon_Latn""", """fra_Latn""", """fur_Latn""", """fuv_Latn""", """gla_Latn""", """gle_Latn""", """glg_Latn""", """grn_Latn""", """guj_Gujr""", """hat_Latn""", """hau_Latn""", """heb_Hebr""", """hin_Deva""", """hne_Deva""", """hrv_Latn""", """hun_Latn""", """hye_Armn""", """ibo_Latn""", """ilo_Latn""", """ind_Latn""", """isl_Latn""", """ita_Latn""", """jav_Latn""", """jpn_Jpan""", """kab_Latn""", """kac_Latn""", """kam_Latn""", """kan_Knda""", """kas_Arab""", """kas_Deva""", """kat_Geor""", """knc_Arab""", """knc_Latn""", """kaz_Cyrl""", """kbp_Latn""", """kea_Latn""", """khm_Khmr""", """kik_Latn""", """kin_Latn""", """kir_Cyrl""", """kmb_Latn""", """kon_Latn""", """kor_Hang""", """kmr_Latn""", """lao_Laoo""", """lvs_Latn""", """lij_Latn""", """lim_Latn""", """lin_Latn""", """lit_Latn""", """lmo_Latn""", """ltg_Latn""", """ltz_Latn""", """lua_Latn""", """lug_Latn""", """luo_Latn""", """lus_Latn""", """mag_Deva""", """mai_Deva""", """mal_Mlym""", """mar_Deva""", """min_Latn""", """mkd_Cyrl""", """plt_Latn""", """mlt_Latn""", """mni_Beng""", """khk_Cyrl""", """mos_Latn""", """mri_Latn""", """zsm_Latn""", """mya_Mymr""", """nld_Latn""", """nno_Latn""", """nob_Latn""", """npi_Deva""", """nso_Latn""", """nus_Latn""", """nya_Latn""", """oci_Latn""", """gaz_Latn""", """ory_Orya""", """pag_Latn""", """pan_Guru""", """pap_Latn""", """pol_Latn""", """por_Latn""", """prs_Arab""", """pbt_Arab""", """quy_Latn""", """ron_Latn""", """run_Latn""", """rus_Cyrl""", """sag_Latn""", """san_Deva""", """sat_Beng""", """scn_Latn""", """shn_Mymr""", """sin_Sinh""", """slk_Latn""", """slv_Latn""", """smo_Latn""", """sna_Latn""", """snd_Arab""", """som_Latn""", """sot_Latn""", """spa_Latn""", """als_Latn""", """srd_Latn""", """srp_Cyrl""", """ssw_Latn""", """sun_Latn""", """swe_Latn""", """swh_Latn""", """szl_Latn""", """tam_Taml""", """tat_Cyrl""", """tel_Telu""", """tgk_Cyrl""", """tgl_Latn""", """tha_Thai""", """tir_Ethi""", """taq_Latn""", """taq_Tfng""", """tpi_Latn""", """tsn_Latn""", """tso_Latn""", """tuk_Latn""", """tum_Latn""", """tur_Latn""", """twi_Latn""", """tzm_Tfng""", """uig_Arab""", """ukr_Cyrl""", """umb_Latn""", """urd_Arab""", """uzn_Latn""", """vec_Latn""", """vie_Latn""", """war_Latn""", """wol_Latn""", """xho_Latn""", """ydd_Hebr""", """yor_Latn""", """yue_Hant""", """zho_Hans""", """zho_Hant""", """zul_Latn"""] class lowerCamelCase_ ( __snake_case ): SCREAMING_SNAKE_CASE_ = VOCAB_FILES_NAMES SCREAMING_SNAKE_CASE_ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES SCREAMING_SNAKE_CASE_ = PRETRAINED_VOCAB_FILES_MAP SCREAMING_SNAKE_CASE_ = ["input_ids", "attention_mask"] SCREAMING_SNAKE_CASE_ = [] SCREAMING_SNAKE_CASE_ = [] def __init__( self : Dict ,__lowerCamelCase : int ,__lowerCamelCase : Any="<s>" ,__lowerCamelCase : Any="</s>" ,__lowerCamelCase : Union[str, Any]="</s>" ,__lowerCamelCase : Dict="<s>" ,__lowerCamelCase : Optional[Any]="<unk>" ,__lowerCamelCase : str="<pad>" ,__lowerCamelCase : Dict="<mask>" ,__lowerCamelCase : Tuple=None ,__lowerCamelCase : List[Any]=None ,__lowerCamelCase : int=None ,__lowerCamelCase : Optional[Dict[str, Any]] = None ,__lowerCamelCase : str=None ,__lowerCamelCase : List[str]=False ,**__lowerCamelCase : Tuple ,): '''simple docstring''' a = AddedToken(lowerCamelCase_ ,lstrip=lowerCamelCase_ ,rstrip=lowerCamelCase_ ) if isinstance(lowerCamelCase_ ,lowerCamelCase_ ) else mask_token a = {} if sp_model_kwargs is None else sp_model_kwargs a = legacy_behaviour super().__init__( bos_token=lowerCamelCase_ ,eos_token=lowerCamelCase_ ,unk_token=lowerCamelCase_ ,sep_token=lowerCamelCase_ ,cls_token=lowerCamelCase_ ,pad_token=lowerCamelCase_ ,mask_token=lowerCamelCase_ ,tokenizer_file=lowerCamelCase_ ,src_lang=lowerCamelCase_ ,tgt_lang=lowerCamelCase_ ,additional_special_tokens=lowerCamelCase_ ,sp_model_kwargs=self.sp_model_kwargs ,legacy_behaviour=lowerCamelCase_ ,**lowerCamelCase_ ,) a = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(str(lowerCamelCase_ ) ) a = vocab_file # Original fairseq vocab and spm vocab must be "aligned": # Vocab | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 # -------- | ------- | ------- | ------ | ------- | ---- | ---- | ---- | ---- | ---- | ---- # fairseq | '<s>' | '<pad>' | '</s>' | '<unk>' | 'an' | '▁n' | '▁m' | '▁t' | '▁k' | '▁a' # spm | '<unk>' | '<s>' | '</s>' | 'an' | '▁n' | '▁m' | '▁t' | '▁k' | '▁a' | '▁s' # Mimic fairseq token-to-id alignment for the first 4 token a = {"""<s>""": 0, """<pad>""": 1, """</s>""": 2, """<unk>""": 3} # The first "real" token "," has position 4 in the original fairseq vocab and position 3 in the spm vocab a = 1 a = len(self.sp_model ) a = { code: self.sp_model_size + i + self.fairseq_offset for i, code in enumerate(lowerCamelCase_ ) } a = {v: k for k, v in self.lang_code_to_id.items()} a = len(self.sp_model ) + len(self.lang_code_to_id ) + self.fairseq_offset self.fairseq_tokens_to_ids.update(self.lang_code_to_id ) a = {v: k for k, v in self.fairseq_tokens_to_ids.items()} a = list(self.lang_code_to_id.keys() ) if additional_special_tokens is not None: # Only add those special tokens if they are not already there. self._additional_special_tokens.extend( [t for t in additional_special_tokens if t not in self._additional_special_tokens] ) a = src_lang if src_lang is not None else """eng_Latn""" a = self.lang_code_to_id[self._src_lang] a = tgt_lang self.set_src_lang_special_tokens(self._src_lang ) def __getstate__( self : str ): '''simple docstring''' a = self.__dict__.copy() a = None a = self.sp_model.serialized_model_proto() return state def __setstate__( self : List[str] ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = d # for backward compatibility if not hasattr(self ,'''sp_model_kwargs''' ): a = {} a = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.LoadFromSerializedProto(self.sp_model_proto ) @property def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' return len(self.sp_model ) + len(self.lang_code_to_id ) + self.fairseq_offset + 1 # Plus 1 for the mask token @property def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ): '''simple docstring''' return self._src_lang @src_lang.setter def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : str ): '''simple docstring''' a = new_src_lang self.set_src_lang_special_tokens(self._src_lang ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : List[int] ,__lowerCamelCase : Optional[List[int]] = None ,__lowerCamelCase : bool = False ): '''simple docstring''' if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=lowerCamelCase_ ,token_ids_a=lowerCamelCase_ ,already_has_special_tokens=lowerCamelCase_ ) a = [1] * len(self.prefix_tokens ) a = [1] * len(self.suffix_tokens ) if token_ids_a is None: return prefix_ones + ([0] * len(lowerCamelCase_ )) + suffix_ones return prefix_ones + ([0] * len(lowerCamelCase_ )) + ([0] * len(lowerCamelCase_ )) + suffix_ones def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : List[int] ,__lowerCamelCase : Optional[List[int]] = None ): '''simple docstring''' if token_ids_a is None: return self.prefix_tokens + token_ids_a + self.suffix_tokens # We don't expect to process pairs, but leave the pair logic for API consistency return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : List[int] ,__lowerCamelCase : Optional[List[int]] = None ): '''simple docstring''' a = [self.sep_token_id] a = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0] def SCREAMING_SNAKE_CASE_ ( self : List[Any] ,__lowerCamelCase : Union[str, Any] ,__lowerCamelCase : str ,__lowerCamelCase : Optional[str] ,__lowerCamelCase : Optional[str] ,**__lowerCamelCase : Dict ): '''simple docstring''' if src_lang is None or tgt_lang is None: raise ValueError('''Translation requires a `src_lang` and a `tgt_lang` for this model''' ) a = src_lang a = self(lowerCamelCase_ ,add_special_tokens=lowerCamelCase_ ,return_tensors=lowerCamelCase_ ,**lowerCamelCase_ ) a = self.convert_tokens_to_ids(lowerCamelCase_ ) a = tgt_lang_id return inputs def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' a = {self.convert_ids_to_tokens(lowerCamelCase_ ): i for i in range(self.vocab_size )} vocab.update(self.added_tokens_encoder ) return vocab def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : str ): '''simple docstring''' return self.sp_model.encode(lowerCamelCase_ ,out_type=lowerCamelCase_ ) def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' if token in self.fairseq_tokens_to_ids: return self.fairseq_tokens_to_ids[token] a = self.sp_model.PieceToId(lowerCamelCase_ ) # Need to return unknown token if the SP model returned 0 return spm_id + self.fairseq_offset if spm_id else self.unk_token_id def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ,__lowerCamelCase : Optional[int] ): '''simple docstring''' if index in self.fairseq_ids_to_tokens: return self.fairseq_ids_to_tokens[index] return self.sp_model.IdToPiece(index - self.fairseq_offset ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = """""".join(lowerCamelCase_ ).replace(lowerCamelCase_ ,''' ''' ).strip() return out_string def SCREAMING_SNAKE_CASE_ ( self : Dict ,__lowerCamelCase : str ,__lowerCamelCase : Optional[str] = None ): '''simple docstring''' if not os.path.isdir(lowerCamelCase_ ): logger.error(F"""Vocabulary path ({save_directory}) should be a directory""" ) return a = 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 = self.sp_model.serialized_model_proto() fi.write(lowerCamelCase_ ) return (out_vocab_file,) def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : List[str] ,__lowerCamelCase : str = "eng_Latn" ,__lowerCamelCase : Optional[List[str]] = None ,__lowerCamelCase : str = "fra_Latn" ,**__lowerCamelCase : Any ,): '''simple docstring''' a = src_lang a = tgt_lang return super().prepare_seqaseq_batch(lowerCamelCase_ ,lowerCamelCase_ ,**lowerCamelCase_ ) def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ): '''simple docstring''' return self.set_src_lang_special_tokens(self.src_lang ) def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ): '''simple docstring''' return self.set_tgt_lang_special_tokens(self.tgt_lang ) def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ,__lowerCamelCase : str ): '''simple docstring''' a = self.lang_code_to_id[src_lang] if self.legacy_behaviour: a = [] a = [self.eos_token_id, self.cur_lang_code] else: a = [self.cur_lang_code] a = [self.eos_token_id] def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ,__lowerCamelCase : str ): '''simple docstring''' a = self.lang_code_to_id[lang] if self.legacy_behaviour: a = [] a = [self.eos_token_id, self.cur_lang_code] else: a = [self.cur_lang_code] a = [self.eos_token_id]
365
from typing import List from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCamelCase__ : Union[str, Any] = logging.get_logger(__name__) UpperCamelCase__ : List[str] = { """snap-research/efficientformer-l1-300""": ( """https://huggingface.co/snap-research/efficientformer-l1-300/resolve/main/config.json""" ), } class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = 'efficientformer' def __init__( self : Optional[int] ,__lowerCamelCase : List[int] = [3, 2, 6, 4] ,__lowerCamelCase : List[int] = [48, 96, 2_24, 4_48] ,__lowerCamelCase : List[bool] = [True, True, True, True] ,__lowerCamelCase : int = 4_48 ,__lowerCamelCase : int = 32 ,__lowerCamelCase : int = 4 ,__lowerCamelCase : int = 7 ,__lowerCamelCase : int = 5 ,__lowerCamelCase : int = 8 ,__lowerCamelCase : int = 4 ,__lowerCamelCase : float = 0.0 ,__lowerCamelCase : int = 16 ,__lowerCamelCase : int = 3 ,__lowerCamelCase : int = 3 ,__lowerCamelCase : int = 3 ,__lowerCamelCase : int = 2 ,__lowerCamelCase : int = 1 ,__lowerCamelCase : float = 0.0 ,__lowerCamelCase : int = 1 ,__lowerCamelCase : bool = True ,__lowerCamelCase : bool = True ,__lowerCamelCase : float = 1e-5 ,__lowerCamelCase : str = "gelu" ,__lowerCamelCase : float = 0.02 ,__lowerCamelCase : float = 1e-12 ,__lowerCamelCase : int = 2_24 ,__lowerCamelCase : float = 1e-05 ,**__lowerCamelCase : Dict ,): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = hidden_act a = hidden_dropout_prob a = hidden_sizes a = num_hidden_layers a = num_attention_heads a = initializer_range a = layer_norm_eps a = patch_size a = num_channels a = depths a = mlp_expansion_ratio a = downsamples a = dim a = key_dim a = attention_ratio a = resolution a = pool_size a = downsample_patch_size a = downsample_stride a = downsample_pad a = drop_path_rate a = num_metaad_blocks a = distillation a = use_layer_scale a = layer_scale_init_value a = image_size a = batch_norm_eps
330
0
import argparse import ast import logging import os import sys import pandas as pd import torch from tqdm import tqdm from transformers import BartForConditionalGeneration, RagRetriever, RagSequenceForGeneration, RagTokenForGeneration from transformers import logging as transformers_logging sys.path.append(os.path.join(os.getcwd())) # noqa: E402 # isort:skip from utils_rag import exact_match_score, fa_score # noqa: E402 # isort:skip UpperCamelCase__ : Dict = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) transformers_logging.set_verbosity_info() def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Any: """simple docstring""" if "token" in model_name_or_path: return "rag_token" if "sequence" in model_name_or_path: return "rag_sequence" if "bart" in model_name_or_path: return "bart" return None def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> List[str]: """simple docstring""" return max(metric_fn(SCREAMING_SNAKE_CASE_, SCREAMING_SNAKE_CASE_ ) for gt in ground_truths ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> Dict: """simple docstring""" a = [line.strip() for line in open(SCREAMING_SNAKE_CASE_, '''r''' ).readlines()] a = [] if args.gold_data_mode == "qa": a = pd.read_csv(SCREAMING_SNAKE_CASE_, sep='''\t''', header=SCREAMING_SNAKE_CASE_ ) for answer_list in data[1]: a = ast.literal_eval(SCREAMING_SNAKE_CASE_ ) answers.append(SCREAMING_SNAKE_CASE_ ) else: a = [line.strip() for line in open(SCREAMING_SNAKE_CASE_, '''r''' ).readlines()] a = [[reference] for reference in references] a = a = a = 0 for prediction, ground_truths in zip(SCREAMING_SNAKE_CASE_, SCREAMING_SNAKE_CASE_ ): total += 1 em += metric_max_over_ground_truths(SCREAMING_SNAKE_CASE_, SCREAMING_SNAKE_CASE_, SCREAMING_SNAKE_CASE_ ) fa += metric_max_over_ground_truths(SCREAMING_SNAKE_CASE_, SCREAMING_SNAKE_CASE_, SCREAMING_SNAKE_CASE_ ) a = 100.0 * em / total a = 100.0 * fa / total logger.info(f"""F1: {fa:.2f}""" ) logger.info(f"""EM: {em:.2f}""" ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> Optional[int]: """simple docstring""" a = args.k a = [line.strip() for line in open(SCREAMING_SNAKE_CASE_, '''r''' ).readlines()] a = [line.strip() for line in open(SCREAMING_SNAKE_CASE_, '''r''' ).readlines()] a = a = 0 for hypo, reference in zip(SCREAMING_SNAKE_CASE_, SCREAMING_SNAKE_CASE_ ): a = set(hypo.split('''\t''' )[:k] ) a = set(reference.split('''\t''' ) ) total += 1 em += len(hypo_provenance & ref_provenance ) / k a = 100.0 * em / total logger.info(f"""Precision@{k}: {em: .2f}""" ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> Union[str, Any]: """simple docstring""" def strip_title(snake_case_ ): if title.startswith('''\"''' ): a = title[1:] if title.endswith('''\"''' ): a = title[:-1] return title a = rag_model.retriever.question_encoder_tokenizer.batch_encode_plus( SCREAMING_SNAKE_CASE_, return_tensors='''pt''', padding=SCREAMING_SNAKE_CASE_, truncation=SCREAMING_SNAKE_CASE_, )['''input_ids'''].to(args.device ) a = rag_model.rag.question_encoder(SCREAMING_SNAKE_CASE_ ) a = question_enc_outputs[0] a = rag_model.retriever( SCREAMING_SNAKE_CASE_, question_enc_pool_output.cpu().detach().to(torch.floataa ).numpy(), prefix=rag_model.rag.generator.config.prefix, n_docs=rag_model.config.n_docs, return_tensors='''pt''', ) a = rag_model.retriever.index.get_doc_dicts(result.doc_ids ) a = [] for docs in all_docs: a = [strip_title(SCREAMING_SNAKE_CASE_ ) for title in docs['''title''']] provenance_strings.append('''\t'''.join(SCREAMING_SNAKE_CASE_ ) ) return provenance_strings def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> str: """simple docstring""" with torch.no_grad(): a = rag_model.retriever.question_encoder_tokenizer.batch_encode_plus( SCREAMING_SNAKE_CASE_, return_tensors='''pt''', padding=SCREAMING_SNAKE_CASE_, truncation=SCREAMING_SNAKE_CASE_ ) a = inputs_dict.input_ids.to(args.device ) a = inputs_dict.attention_mask.to(args.device ) a = rag_model.generate( # rag_model overwrites generate SCREAMING_SNAKE_CASE_, attention_mask=SCREAMING_SNAKE_CASE_, num_beams=args.num_beams, min_length=args.min_length, max_length=args.max_length, early_stopping=SCREAMING_SNAKE_CASE_, num_return_sequences=1, bad_words_ids=[[0, 0]], ) a = rag_model.retriever.generator_tokenizer.batch_decode(SCREAMING_SNAKE_CASE_, skip_special_tokens=SCREAMING_SNAKE_CASE_ ) if args.print_predictions: for q, a in zip(SCREAMING_SNAKE_CASE_, SCREAMING_SNAKE_CASE_ ): logger.info('''Q: {} - A: {}'''.format(SCREAMING_SNAKE_CASE_, SCREAMING_SNAKE_CASE_ ) ) return answers def SCREAMING_SNAKE_CASE__ ( ) -> List[str]: """simple docstring""" a = argparse.ArgumentParser() parser.add_argument( '''--model_type''', choices=['''rag_sequence''', '''rag_token''', '''bart'''], type=SCREAMING_SNAKE_CASE_, help=( '''RAG model type: rag_sequence, rag_token or bart, if none specified, the type is inferred from the''' ''' model_name_or_path''' ), ) parser.add_argument( '''--index_name''', default=SCREAMING_SNAKE_CASE_, choices=['''exact''', '''compressed''', '''legacy'''], type=SCREAMING_SNAKE_CASE_, help='''RAG model retriever type''', ) parser.add_argument( '''--index_path''', default=SCREAMING_SNAKE_CASE_, type=SCREAMING_SNAKE_CASE_, help='''Path to the retrieval index''', ) parser.add_argument('''--n_docs''', default=5, type=SCREAMING_SNAKE_CASE_, help='''Number of retrieved docs''' ) parser.add_argument( '''--model_name_or_path''', default=SCREAMING_SNAKE_CASE_, type=SCREAMING_SNAKE_CASE_, required=SCREAMING_SNAKE_CASE_, help='''Path to pretrained checkpoints or model identifier from huggingface.co/models''', ) parser.add_argument( '''--eval_mode''', choices=['''e2e''', '''retrieval'''], default='''e2e''', type=SCREAMING_SNAKE_CASE_, help=( '''Evaluation mode, e2e calculates exact match and F1 of the downstream task, retrieval calculates''' ''' precision@k.''' ), ) parser.add_argument('''--k''', default=1, type=SCREAMING_SNAKE_CASE_, help='''k for the precision@k calculation''' ) parser.add_argument( '''--evaluation_set''', default=SCREAMING_SNAKE_CASE_, type=SCREAMING_SNAKE_CASE_, required=SCREAMING_SNAKE_CASE_, help='''Path to a file containing evaluation samples''', ) parser.add_argument( '''--gold_data_path''', default=SCREAMING_SNAKE_CASE_, type=SCREAMING_SNAKE_CASE_, required=SCREAMING_SNAKE_CASE_, help='''Path to a tab-separated file with gold samples''', ) parser.add_argument( '''--gold_data_mode''', default='''qa''', type=SCREAMING_SNAKE_CASE_, choices=['''qa''', '''ans'''], help=( '''Format of the gold data file''' '''qa - a single line in the following format: question [tab] answer_list''' '''ans - a single line of the gold file contains the expected answer string''' ), ) parser.add_argument( '''--predictions_path''', type=SCREAMING_SNAKE_CASE_, default='''predictions.txt''', help='''Name of the predictions file, to be stored in the checkpoints directory''', ) parser.add_argument( '''--eval_all_checkpoints''', action='''store_true''', help='''Evaluate all checkpoints starting with the same prefix as model_name ending and ending with step number''', ) parser.add_argument( '''--eval_batch_size''', default=8, type=SCREAMING_SNAKE_CASE_, help='''Batch size per GPU/CPU for evaluation.''', ) parser.add_argument( '''--recalculate''', help='''Recalculate predictions even if the prediction file exists''', action='''store_true''', ) parser.add_argument( '''--num_beams''', default=4, type=SCREAMING_SNAKE_CASE_, help='''Number of beams to be used when generating answers''', ) parser.add_argument('''--min_length''', default=1, type=SCREAMING_SNAKE_CASE_, help='''Min length of the generated answers''' ) parser.add_argument('''--max_length''', default=5_0, type=SCREAMING_SNAKE_CASE_, help='''Max length of the generated answers''' ) parser.add_argument( '''--print_predictions''', action='''store_true''', help='''If True, prints predictions while evaluating.''', ) parser.add_argument( '''--print_docs''', action='''store_true''', help='''If True, prints docs retried while generating.''', ) a = parser.parse_args() a = torch.device('''cuda''' if torch.cuda.is_available() else '''cpu''' ) return args def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> str: """simple docstring""" a = {} if args.model_type is None: a = infer_model_type(args.model_name_or_path ) assert args.model_type is not None if args.model_type.startswith('''rag''' ): a = RagTokenForGeneration if args.model_type == '''rag_token''' else RagSequenceForGeneration a = args.n_docs if args.index_name is not None: a = args.index_name if args.index_path is not None: a = args.index_path else: a = BartForConditionalGeneration a = ( [f.path for f in os.scandir(args.model_name_or_path ) if f.is_dir()] if args.eval_all_checkpoints else [args.model_name_or_path] ) logger.info('''Evaluate the following checkpoints: %s''', SCREAMING_SNAKE_CASE_ ) a = get_scores if args.eval_mode == '''e2e''' else get_precision_at_k a = evaluate_batch_eae if args.eval_mode == '''e2e''' else evaluate_batch_retrieval for checkpoint in checkpoints: if os.path.exists(args.predictions_path ) and (not args.recalculate): logger.info('''Calculating metrics based on an existing predictions file: {}'''.format(args.predictions_path ) ) score_fn(SCREAMING_SNAKE_CASE_, args.predictions_path, args.gold_data_path ) continue logger.info('''***** Running evaluation for {} *****'''.format(SCREAMING_SNAKE_CASE_ ) ) logger.info(''' Batch size = %d''', args.eval_batch_size ) logger.info(''' Predictions will be stored under {}'''.format(args.predictions_path ) ) if args.model_type.startswith('''rag''' ): a = RagRetriever.from_pretrained(SCREAMING_SNAKE_CASE_, **SCREAMING_SNAKE_CASE_ ) a = model_class.from_pretrained(SCREAMING_SNAKE_CASE_, retriever=SCREAMING_SNAKE_CASE_, **SCREAMING_SNAKE_CASE_ ) model.retriever.init_retrieval() else: a = model_class.from_pretrained(SCREAMING_SNAKE_CASE_, **SCREAMING_SNAKE_CASE_ ) model.to(args.device ) with open(args.evaluation_set, '''r''' ) as eval_file, open(args.predictions_path, '''w''' ) as preds_file: a = [] for line in tqdm(SCREAMING_SNAKE_CASE_ ): questions.append(line.strip() ) if len(SCREAMING_SNAKE_CASE_ ) == args.eval_batch_size: a = evaluate_batch_fn(SCREAMING_SNAKE_CASE_, SCREAMING_SNAKE_CASE_, SCREAMING_SNAKE_CASE_ ) preds_file.write('''\n'''.join(SCREAMING_SNAKE_CASE_ ) + '''\n''' ) preds_file.flush() a = [] if len(SCREAMING_SNAKE_CASE_ ) > 0: a = evaluate_batch_fn(SCREAMING_SNAKE_CASE_, SCREAMING_SNAKE_CASE_, SCREAMING_SNAKE_CASE_ ) preds_file.write('''\n'''.join(SCREAMING_SNAKE_CASE_ ) ) preds_file.flush() score_fn(SCREAMING_SNAKE_CASE_, args.predictions_path, args.gold_data_path ) if __name__ == "__main__": UpperCamelCase__ : List[Any] = get_args() main(args)
366
import argparse from typing import Dict import tensorflow as tf import torch from tqdm import tqdm from transformers import BigBirdPegasusConfig, BigBirdPegasusForConditionalGeneration UpperCamelCase__ : Any = [ # tf -> hf ("""/""", """."""), ("""layer_""", """layers."""), ("""kernel""", """weight"""), ("""beta""", """bias"""), ("""gamma""", """weight"""), ("""pegasus""", """model"""), ] UpperCamelCase__ : Optional[Any] = [ (""".output.dense""", """.fc2"""), ("""intermediate.LayerNorm""", """final_layer_norm"""), ("""intermediate.dense""", """fc1"""), ] UpperCamelCase__ : Optional[Any] = ( INIT_COMMON + [ ("""attention.self.LayerNorm""", """self_attn_layer_norm"""), ("""attention.output.dense""", """self_attn.out_proj"""), ("""attention.self""", """self_attn"""), ("""attention.encdec.LayerNorm""", """encoder_attn_layer_norm"""), ("""attention.encdec_output.dense""", """encoder_attn.out_proj"""), ("""attention.encdec""", """encoder_attn"""), ("""key""", """k_proj"""), ("""value""", """v_proj"""), ("""query""", """q_proj"""), ("""decoder.LayerNorm""", """decoder.layernorm_embedding"""), ] + END_COMMON ) UpperCamelCase__ : List[str] = ( INIT_COMMON + [ ("""embeddings.word_embeddings""", """shared.weight"""), ("""embeddings.position_embeddings""", """embed_positions.weight"""), ("""attention.self.LayerNorm""", """self_attn_layer_norm"""), ("""attention.output.dense""", """self_attn.output"""), ("""attention.self""", """self_attn.self"""), ("""encoder.LayerNorm""", """encoder.layernorm_embedding"""), ] + END_COMMON ) UpperCamelCase__ : Optional[int] = [ """encdec/key/bias""", """encdec/query/bias""", """encdec/value/bias""", """self/key/bias""", """self/query/bias""", """self/value/bias""", """encdec_output/dense/bias""", """attention/output/dense/bias""", ] def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> List[Any]: """simple docstring""" for tf_name, hf_name in patterns: a = k.replace(snake_case_, snake_case_ ) return k def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> BigBirdPegasusForConditionalGeneration: """simple docstring""" a = BigBirdPegasusConfig(**snake_case_ ) a = BigBirdPegasusForConditionalGeneration(snake_case_ ) a = torch_model.state_dict() a = {} # separating decoder weights a = {k: tf_weights[k] for k in tf_weights if k.startswith('''pegasus/decoder''' )} a = {k: tf_weights[k] for k in tf_weights if not k.startswith('''pegasus/decoder''' )} for k, v in tqdm(decoder_weights.items(), '''tf -> hf conversion''' ): a = [k.endswith(snake_case_ ) for ending in KEYS_TO_IGNORE] if any(snake_case_ ): continue a = DECODER_PATTERNS a = rename_state_dict_key(snake_case_, snake_case_ ) if new_k not in state_dict: raise ValueError(f"""could not find new key {new_k} in state dict. (converted from {k})""" ) if any(True if i in k else False for i in ['''dense''', '''query''', '''key''', '''value'''] ): a = v.T a = torch.from_numpy(snake_case_ ) assert v.shape == state_dict[new_k].shape, f"""{new_k}, {k}, {v.shape}, {state_dict[new_k].shape}""" for k, v in tqdm(remaining_weights.items(), '''tf -> hf conversion''' ): a = [k.endswith(snake_case_ ) for ending in KEYS_TO_IGNORE] if any(snake_case_ ): continue a = REMAINING_PATTERNS a = rename_state_dict_key(snake_case_, snake_case_ ) if new_k not in state_dict and k != "pegasus/embeddings/position_embeddings": raise ValueError(f"""could not find new key {new_k} in state dict. (converted from {k})""" ) if any(True if i in k else False for i in ['''dense''', '''query''', '''key''', '''value'''] ): a = v.T a = torch.from_numpy(snake_case_ ) if k != "pegasus/embeddings/position_embeddings": assert v.shape == state_dict[new_k].shape, f"""{new_k}, {k}, {v.shape}, {state_dict[new_k].shape}""" a = mapping['''model.embed_positions.weight'''] a = mapping.pop('''model.embed_positions.weight''' ) a , a = torch_model.load_state_dict(snake_case_, strict=snake_case_ ) a = [ k for k in missing if k not in [ '''final_logits_bias''', '''model.encoder.embed_tokens.weight''', '''model.decoder.embed_tokens.weight''', '''lm_head.weight''', ] ] assert unexpected_missing == [], f"""no matches found for the following torch keys {unexpected_missing}""" assert extra == [], f"""no matches found for the following tf keys {extra}""" return torch_model def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Dict: """simple docstring""" a = tf.train.list_variables(snake_case_ ) a = {} a = ['''global_step'''] for name, shape in tqdm(snake_case_, desc='''converting tf checkpoint to dict''' ): a = any(pat in name for pat in ignore_name ) if skip_key: continue a = tf.train.load_variable(snake_case_, snake_case_ ) a = array return tf_weights def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> int: """simple docstring""" a = get_tf_weights_as_numpy(snake_case_ ) a = convert_bigbird_pegasus(snake_case_, snake_case_ ) torch_model.save_pretrained(snake_case_ ) if __name__ == "__main__": UpperCamelCase__ : str = argparse.ArgumentParser() parser.add_argument("""--tf_ckpt_path""", type=str, help="""passed to tf.train.list_variables""") parser.add_argument("""--save_dir""", default=None, type=str, help="""Path to the output PyTorch model.""") UpperCamelCase__ : int = parser.parse_args() UpperCamelCase__ : Tuple = {} convert_bigbird_pegasus_ckpt_to_pytorch(args.tf_ckpt_path, args.save_dir, config_update=config_update)
330
0
import os from collections.abc import Iterator def SCREAMING_SNAKE_CASE__ ( snake_case_ = "." ) -> Dict: """simple docstring""" for dir_path, dir_names, filenames in os.walk(SCREAMING_SNAKE_CASE__ ): a = [d for d in dir_names if d != '''scripts''' and d[0] not in '''._'''] for filename in filenames: if filename == "__init__.py": continue if os.path.splitext(SCREAMING_SNAKE_CASE__ )[1] in (".py", ".ipynb"): yield os.path.join(SCREAMING_SNAKE_CASE__, SCREAMING_SNAKE_CASE__ ).lstrip('''./''' ) def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Any: """simple docstring""" return f"""{i * " "}*""" if i else "\n##" def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> Dict: """simple docstring""" a = old_path.split(os.sep ) for i, new_part in enumerate(new_path.split(os.sep ) ): if (i + 1 > len(SCREAMING_SNAKE_CASE__ ) or old_parts[i] != new_part) and new_part: print(f"""{md_prefix(SCREAMING_SNAKE_CASE__ )} {new_part.replace("_", " " ).title()}""" ) return new_path def SCREAMING_SNAKE_CASE__ ( snake_case_ = "." ) -> str: """simple docstring""" a = '''''' for filepath in sorted(good_file_paths(SCREAMING_SNAKE_CASE__ ) ): a , a = os.path.split(SCREAMING_SNAKE_CASE__ ) if filepath != old_path: a = print_path(SCREAMING_SNAKE_CASE__, SCREAMING_SNAKE_CASE__ ) a = (filepath.count(os.sep ) + 1) if filepath else 0 a = f"""{filepath}/{filename}""".replace(''' ''', '''%20''' ) a = os.path.splitext(filename.replace('''_''', ''' ''' ).title() )[0] print(f"""{md_prefix(SCREAMING_SNAKE_CASE__ )} [{filename}]({url})""" ) if __name__ == "__main__": print_directory_md(""".""")
367
import re def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> str: """simple docstring""" if len(re.findall('''[ATCG]''', snake_case_ ) ) != len(snake_case_ ): raise ValueError('''Invalid Strand''' ) return dna.translate(dna.maketrans('''ATCG''', '''TAGC''' ) ) if __name__ == "__main__": import doctest doctest.testmod()
330
0
"""simple docstring""" import unittest import torch from diffusers import VQModel from diffusers.utils import floats_tensor, torch_device from diffusers.utils.testing_utils import enable_full_determinism from .test_modeling_common import ModelTesterMixin, UNetTesterMixin enable_full_determinism() class lowerCamelCase_ ( _a , _a , unittest.TestCase ): SCREAMING_SNAKE_CASE_ = VQModel SCREAMING_SNAKE_CASE_ = """sample""" @property def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : int=(32, 32) ): '''simple docstring''' a = 4 a = 3 a = floats_tensor((batch_size, num_channels) + sizes ).to(__lowerCamelCase ) return {"sample": image} @property def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' return (3, 32, 32) @property def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ): '''simple docstring''' return (3, 32, 32) def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' a = { """block_out_channels""": [32, 64], """in_channels""": 3, """out_channels""": 3, """down_block_types""": ["""DownEncoderBlock2D""", """DownEncoderBlock2D"""], """up_block_types""": ["""UpDecoderBlock2D""", """UpDecoderBlock2D"""], """latent_channels""": 3, } a = self.dummy_input return init_dict, inputs_dict def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' pass def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' pass def SCREAMING_SNAKE_CASE_ ( self : Tuple ): '''simple docstring''' a = VQModel.from_pretrained('''fusing/vqgan-dummy''' ,output_loading_info=__lowerCamelCase ) self.assertIsNotNone(__lowerCamelCase ) self.assertEqual(len(loading_info['''missing_keys'''] ) ,0 ) model.to(__lowerCamelCase ) a = model(**self.dummy_input ) assert image is not None, "Make sure output is not None" def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' a = VQModel.from_pretrained('''fusing/vqgan-dummy''' ) model.to(__lowerCamelCase ).eval() torch.manual_seed(0 ) if torch.cuda.is_available(): torch.cuda.manual_seed_all(0 ) a = torch.randn(1 ,model.config.in_channels ,model.config.sample_size ,model.config.sample_size ) a = image.to(__lowerCamelCase ) with torch.no_grad(): a = model(__lowerCamelCase ).sample a = output[0, -1, -3:, -3:].flatten().cpu() # fmt: off a = torch.tensor([-0.0_153, -0.4_044, -0.1_880, -0.5_161, -0.2_418, -0.4_072, -0.1_612, -0.0_633, -0.0_143] ) # fmt: on self.assertTrue(torch.allclose(__lowerCamelCase ,__lowerCamelCase ,atol=1e-3 ) )
368
from __future__ import annotations from collections.abc import Sequence from typing import Literal def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> str | Literal[False]: """simple docstring""" a = list(snake_case_ ) a = list(snake_case_ ) a = 0 for i in range(len(snake_case_ ) ): if lista[i] != lista[i]: count += 1 a = '''_''' if count > 1: return False else: return "".join(snake_case_ ) def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> list[str]: """simple docstring""" a = [] while True: a = ['''$'''] * len(snake_case_ ) a = [] for i in range(len(snake_case_ ) ): for j in range(i + 1, len(snake_case_ ) ): a = compare_string(binary[i], binary[j] ) if k is False: a = '''*''' a = '''*''' temp.append('''X''' ) for i in range(len(snake_case_ ) ): if checka[i] == "$": pi.append(binary[i] ) if len(snake_case_ ) == 0: return pi a = list(set(snake_case_ ) ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> list[str]: """simple docstring""" a = [] for minterm in minterms: a = '''''' for _ in range(snake_case_ ): a = str(minterm % 2 ) + string minterm //= 2 temp.append(snake_case_ ) return temp def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> bool: """simple docstring""" a = list(snake_case_ ) a = list(snake_case_ ) a = 0 for i in range(len(snake_case_ ) ): if lista[i] != lista[i]: count_n += 1 return count_n == count def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> list[str]: """simple docstring""" a = [] a = [0] * len(snake_case_ ) for i in range(len(chart[0] ) ): a = 0 a = -1 for j in range(len(snake_case_ ) ): if chart[j][i] == 1: count += 1 a = j if count == 1: a = 1 for i in range(len(snake_case_ ) ): if select[i] == 1: for j in range(len(chart[0] ) ): if chart[i][j] == 1: for k in range(len(snake_case_ ) ): a = 0 temp.append(prime_implicants[i] ) while True: a = 0 a = -1 a = 0 for i in range(len(snake_case_ ) ): a = chart[i].count(1 ) if count_n > max_n: a = count_n a = i if max_n == 0: return temp temp.append(prime_implicants[rem] ) for i in range(len(chart[0] ) ): if chart[rem][i] == 1: for j in range(len(snake_case_ ) ): a = 0 def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> list[list[int]]: """simple docstring""" a = [[0 for x in range(len(snake_case_ ) )] for x in range(len(snake_case_ ) )] for i in range(len(snake_case_ ) ): a = prime_implicants[i].count('''_''' ) for j in range(len(snake_case_ ) ): if is_for_table(prime_implicants[i], binary[j], snake_case_ ): a = 1 return chart def SCREAMING_SNAKE_CASE__ ( ) -> None: """simple docstring""" a = int(input('''Enter the no. of variables\n''' ) ) a = [ float(snake_case_ ) for x in input( '''Enter the decimal representation of Minterms \'Spaces Separated\'\n''' ).split() ] a = decimal_to_binary(snake_case_, snake_case_ ) a = check(snake_case_ ) print('''Prime Implicants are:''' ) print(snake_case_ ) a = prime_implicant_chart(snake_case_, snake_case_ ) a = selection(snake_case_, snake_case_ ) print('''Essential Prime Implicants are:''' ) print(snake_case_ ) if __name__ == "__main__": import doctest doctest.testmod() main()
330
0
import unittest import numpy as np import timeout_decorator # noqa from transformers import BlenderbotConfig, is_flax_available from transformers.testing_utils import jax_device, require_flax, slow from ...generation.test_flax_utils import FlaxGenerationTesterMixin from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor if is_flax_available(): import os # The slow tests are often failing with OOM error on GPU # This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed # but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html UpperCamelCase__ : Dict = """platform""" import jax import jax.numpy as jnp from transformers import BlenderbotTokenizer from transformers.models.blenderbot.modeling_flax_blenderbot import ( FlaxBlenderbotForConditionalGeneration, FlaxBlenderbotModel, shift_tokens_right, ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_=None, snake_case_=None, snake_case_=None, snake_case_=None, snake_case_=None, snake_case_=None, ) -> List[Any]: """simple docstring""" if attention_mask is None: a = np.where(input_ids != config.pad_token_id, 1, 0 ) if decoder_attention_mask is None: a = np.where(decoder_input_ids != config.pad_token_id, 1, 0 ) if head_mask is None: a = np.ones((config.encoder_layers, config.encoder_attention_heads) ) if decoder_head_mask is None: a = np.ones((config.decoder_layers, config.decoder_attention_heads) ) if cross_attn_head_mask is None: a = np.ones((config.decoder_layers, config.decoder_attention_heads) ) return { "input_ids": input_ids, "decoder_input_ids": decoder_input_ids, "attention_mask": attention_mask, "decoder_attention_mask": attention_mask, } class lowerCamelCase_ : def __init__( self : List[str] ,__lowerCamelCase : Tuple ,__lowerCamelCase : List[str]=13 ,__lowerCamelCase : int=7 ,__lowerCamelCase : Any=True ,__lowerCamelCase : Tuple=False ,__lowerCamelCase : Tuple=99 ,__lowerCamelCase : Optional[int]=16 ,__lowerCamelCase : Any=2 ,__lowerCamelCase : Optional[Any]=4 ,__lowerCamelCase : List[Any]=4 ,__lowerCamelCase : Tuple="gelu" ,__lowerCamelCase : str=0.1 ,__lowerCamelCase : List[str]=0.1 ,__lowerCamelCase : List[Any]=32 ,__lowerCamelCase : str=2 ,__lowerCamelCase : str=1 ,__lowerCamelCase : Union[str, Any]=0 ,__lowerCamelCase : Tuple=0.02 ,): '''simple docstring''' a = parent a = batch_size a = seq_length a = is_training a = use_labels a = vocab_size a = hidden_size a = num_hidden_layers a = num_attention_heads a = intermediate_size a = hidden_act a = hidden_dropout_prob a = attention_probs_dropout_prob a = max_position_embeddings a = eos_token_id a = pad_token_id a = bos_token_id a = initializer_range def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ): '''simple docstring''' a = np.clip(ids_tensor([self.batch_size, self.seq_length - 1] ,self.vocab_size ) ,3 ,self.vocab_size ) a = np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1) ,dtype=np.intaa )) ,-1 ) a = shift_tokens_right(lowercase_ ,1 ,2 ) a = BlenderbotConfig( vocab_size=self.vocab_size ,d_model=self.hidden_size ,encoder_layers=self.num_hidden_layers ,decoder_layers=self.num_hidden_layers ,encoder_attention_heads=self.num_attention_heads ,decoder_attention_heads=self.num_attention_heads ,encoder_ffn_dim=self.intermediate_size ,decoder_ffn_dim=self.intermediate_size ,dropout=self.hidden_dropout_prob ,attention_dropout=self.attention_probs_dropout_prob ,max_position_embeddings=self.max_position_embeddings ,eos_token_id=self.eos_token_id ,bos_token_id=self.bos_token_id ,pad_token_id=self.pad_token_id ,initializer_range=self.initializer_range ,use_cache=lowercase_ ,) a = prepare_blenderbot_inputs_dict(lowercase_ ,lowercase_ ,lowercase_ ) return config, inputs_dict def SCREAMING_SNAKE_CASE_ ( self : int ): '''simple docstring''' a , a = self.prepare_config_and_inputs() return config, inputs_dict def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : str ,__lowerCamelCase : Union[str, Any] ,__lowerCamelCase : Optional[int] ): '''simple docstring''' a = 20 a = model_class_name(lowercase_ ) a = model.encode(inputs_dict['''input_ids'''] ) a , a = ( inputs_dict['''decoder_input_ids'''], inputs_dict['''decoder_attention_mask'''], ) a = model.init_cache(decoder_input_ids.shape[0] ,lowercase_ ,lowercase_ ) a = jnp.ones((decoder_input_ids.shape[0], max_decoder_length) ,dtype='''i4''' ) a = jnp.broadcast_to( jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :] ,(decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1) ,) a = model.decode( decoder_input_ids[:, :-1] ,lowercase_ ,decoder_attention_mask=lowercase_ ,past_key_values=lowercase_ ,decoder_position_ids=lowercase_ ,) a = jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]] ,dtype='''i4''' ) a = model.decode( decoder_input_ids[:, -1:] ,lowercase_ ,decoder_attention_mask=lowercase_ ,past_key_values=outputs_cache.past_key_values ,decoder_position_ids=lowercase_ ,) a = model.decode(lowercase_ ,lowercase_ ) a = np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) ) self.parent.assertTrue(diff < 1e-3 ,msg=F"""Max diff is {diff}""" ) def SCREAMING_SNAKE_CASE_ ( self : Dict ,__lowerCamelCase : List[Any] ,__lowerCamelCase : int ,__lowerCamelCase : Optional[Any] ): '''simple docstring''' a = 20 a = model_class_name(lowercase_ ) a = model.encode(inputs_dict['''input_ids'''] ) a , a = ( inputs_dict['''decoder_input_ids'''], inputs_dict['''decoder_attention_mask'''], ) a = jnp.concatenate( [ decoder_attention_mask, jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1]) ), ] ,axis=-1 ,) a = model.init_cache(decoder_input_ids.shape[0] ,lowercase_ ,lowercase_ ) a = jnp.broadcast_to( jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :] ,(decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1) ,) a = model.decode( decoder_input_ids[:, :-1] ,lowercase_ ,decoder_attention_mask=lowercase_ ,past_key_values=lowercase_ ,decoder_position_ids=lowercase_ ,) a = jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]] ,dtype='''i4''' ) a = model.decode( decoder_input_ids[:, -1:] ,lowercase_ ,past_key_values=outputs_cache.past_key_values ,decoder_attention_mask=lowercase_ ,decoder_position_ids=lowercase_ ,) a = model.decode(lowercase_ ,lowercase_ ,decoder_attention_mask=lowercase_ ) a = np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) ) self.parent.assertTrue(diff < 1e-3 ,msg=F"""Max diff is {diff}""" ) @require_flax class lowerCamelCase_ ( unittest.TestCase ): SCREAMING_SNAKE_CASE_ = 99 def SCREAMING_SNAKE_CASE_ ( self : List[str] ): '''simple docstring''' a = np.array( [ [71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 82, 2], [5, 97, 17, 39, 94, 40, 2], [76, 83, 94, 25, 70, 78, 2], [87, 59, 41, 35, 48, 66, 2], [55, 13, 16, 58, 5, 2, 1], # note padding [64, 27, 31, 51, 12, 75, 2], [52, 64, 86, 17, 83, 39, 2], [48, 61, 9, 24, 71, 82, 2], [26, 1, 60, 48, 22, 13, 2], [21, 5, 62, 28, 14, 76, 2], [45, 98, 37, 86, 59, 48, 2], [70, 70, 50, 9, 28, 0, 2], ] ,dtype=np.intaa ,) a = input_ids.shape[0] a = BlenderbotConfig( vocab_size=self.vocab_size ,d_model=24 ,encoder_layers=2 ,decoder_layers=2 ,encoder_attention_heads=2 ,decoder_attention_heads=2 ,encoder_ffn_dim=32 ,decoder_ffn_dim=32 ,max_position_embeddings=48 ,eos_token_id=2 ,pad_token_id=1 ,bos_token_id=0 ,) return config, input_ids, batch_size def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ): '''simple docstring''' a , a , a = self._get_config_and_data() a = FlaxBlenderbotForConditionalGeneration(lowercase_ ) a = lm_model(input_ids=lowercase_ ) a = (batch_size, input_ids.shape[1], config.vocab_size) self.assertEqual(outputs['''logits'''].shape ,lowercase_ ) def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ): '''simple docstring''' a = BlenderbotConfig( vocab_size=self.vocab_size ,d_model=14 ,encoder_layers=2 ,decoder_layers=2 ,encoder_attention_heads=2 ,decoder_attention_heads=2 ,encoder_ffn_dim=8 ,decoder_ffn_dim=8 ,max_position_embeddings=48 ,) a = FlaxBlenderbotForConditionalGeneration(lowercase_ ) a = np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]] ,dtype=np.intaa ) a = np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]] ,dtype=np.intaa ) a = lm_model(input_ids=lowercase_ ,decoder_input_ids=lowercase_ ) a = (*summary.shape, config.vocab_size) self.assertEqual(outputs['''logits'''].shape ,lowercase_ ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ): '''simple docstring''' a = np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]] ,dtype=np.intaa ) a = shift_tokens_right(lowercase_ ,1 ,2 ) a = np.equal(lowercase_ ,1 ).astype(np.floataa ).sum() a = np.equal(lowercase_ ,1 ).astype(np.floataa ).sum() self.assertEqual(shifted.shape ,input_ids.shape ) self.assertEqual(lowercase_ ,n_pad_before - 1 ) self.assertTrue(np.equal(shifted[:, 0] ,2 ).all() ) @require_flax class lowerCamelCase_ ( a_ , unittest.TestCase , a_ ): SCREAMING_SNAKE_CASE_ = True SCREAMING_SNAKE_CASE_ = ( ( FlaxBlenderbotModel, FlaxBlenderbotForConditionalGeneration, ) if is_flax_available() else () ) SCREAMING_SNAKE_CASE_ = (FlaxBlenderbotForConditionalGeneration,) if is_flax_available() else () def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' a = FlaxBlenderbotModelTester(self ) def SCREAMING_SNAKE_CASE_ ( self : int ): '''simple docstring''' a , a = self.model_tester.prepare_config_and_inputs() for model_class in self.all_model_classes: self.model_tester.check_use_cache_forward(lowercase_ ,lowercase_ ,lowercase_ ) def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' a , a = self.model_tester.prepare_config_and_inputs() for model_class in self.all_model_classes: self.model_tester.check_use_cache_forward_with_attn_mask(lowercase_ ,lowercase_ ,lowercase_ ) def SCREAMING_SNAKE_CASE_ ( self : int ): '''simple docstring''' a , a = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: with self.subTest(model_class.__name__ ): a = self._prepare_for_class(lowercase_ ,lowercase_ ) a = model_class(lowercase_ ) @jax.jit def encode_jitted(__lowerCamelCase : int ,__lowerCamelCase : Any=None ,**__lowerCamelCase : str ): return model.encode(input_ids=lowercase_ ,attention_mask=lowercase_ ) with self.subTest('''JIT Enabled''' ): a = encode_jitted(**lowercase_ ).to_tuple() with self.subTest('''JIT Disabled''' ): with jax.disable_jit(): a = encode_jitted(**lowercase_ ).to_tuple() self.assertEqual(len(lowercase_ ) ,len(lowercase_ ) ) for jitted_output, output in zip(lowercase_ ,lowercase_ ): self.assertEqual(jitted_output.shape ,output.shape ) def SCREAMING_SNAKE_CASE_ ( self : int ): '''simple docstring''' a , a = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: with self.subTest(model_class.__name__ ): a = model_class(lowercase_ ) a = model.encode(inputs_dict['''input_ids'''] ,inputs_dict['''attention_mask'''] ) a = { '''decoder_input_ids''': inputs_dict['''decoder_input_ids'''], '''decoder_attention_mask''': inputs_dict['''decoder_attention_mask'''], '''encoder_outputs''': encoder_outputs, } @jax.jit def decode_jitted(__lowerCamelCase : int ,__lowerCamelCase : Tuple ,__lowerCamelCase : Any ): return model.decode( decoder_input_ids=lowercase_ ,decoder_attention_mask=lowercase_ ,encoder_outputs=lowercase_ ,) with self.subTest('''JIT Enabled''' ): a = decode_jitted(**lowercase_ ).to_tuple() with self.subTest('''JIT Disabled''' ): with jax.disable_jit(): a = decode_jitted(**lowercase_ ).to_tuple() self.assertEqual(len(lowercase_ ) ,len(lowercase_ ) ) for jitted_output, output in zip(lowercase_ ,lowercase_ ): self.assertEqual(jitted_output.shape ,output.shape ) @slow def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' for model_class_name in self.all_model_classes: a = model_class_name.from_pretrained('''facebook/blenderbot-400M-distill''' ) # FlaxBlenderbotForSequenceClassification expects eos token in input_ids a = np.ones((1, 1) ) * model.config.eos_token_id a = model(lowercase_ ) self.assertIsNotNone(lowercase_ ) @unittest.skipUnless(jax_device != '''cpu''' ,'''3B test too slow on CPU.''' ) @slow def SCREAMING_SNAKE_CASE_ ( self : Tuple ): '''simple docstring''' a = {'''num_beams''': 1, '''early_stopping''': True, '''min_length''': 15, '''max_length''': 25} a = {'''skip_special_tokens''': True, '''clean_up_tokenization_spaces''': True} a = FlaxBlenderbotForConditionalGeneration.from_pretrained('''facebook/blenderbot-3B''' ,from_pt=lowercase_ ) a = BlenderbotTokenizer.from_pretrained('''facebook/blenderbot-3B''' ) a = ['''Sam'''] a = tokenizer(lowercase_ ,return_tensors='''jax''' ) a = model.generate(**lowercase_ ,**lowercase_ ) a = '''Sam is a great name. It means \"sun\" in Gaelic.''' a = tokenizer.batch_decode(lowercase_ ,**lowercase_ ) assert generated_txt[0].strip() == tgt_text
369
from typing import List, Union import numpy as np from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_torch_available(): import torch from ..models.auto.modeling_auto import MODEL_FOR_DEPTH_ESTIMATION_MAPPING UpperCamelCase__ : List[str] = logging.get_logger(__name__) @add_end_docstrings(a_ ) class lowerCamelCase_ ( a_ ): def __init__( self : int ,*__lowerCamelCase : str ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' super().__init__(*__lowerCamelCase ,**__lowerCamelCase ) requires_backends(self ,'''vision''' ) self.check_model_type(__lowerCamelCase ) def __call__( self : int ,__lowerCamelCase : Union[str, List[str], "Image.Image", List["Image.Image"]] ,**__lowerCamelCase : str ): '''simple docstring''' return super().__call__(__lowerCamelCase ,**__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Any ,**__lowerCamelCase : Dict ): '''simple docstring''' return {}, {}, {} def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = load_image(__lowerCamelCase ) a = image.size a = self.image_processor(images=__lowerCamelCase ,return_tensors=self.framework ) return model_inputs def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = self.model(**__lowerCamelCase ) return model_outputs def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = model_outputs.predicted_depth a = torch.nn.functional.interpolate( predicted_depth.unsqueeze(1 ) ,size=self.image_size[::-1] ,mode='''bicubic''' ,align_corners=__lowerCamelCase ) a = prediction.squeeze().cpu().numpy() a = (output * 2_55 / np.max(__lowerCamelCase )).astype('''uint8''' ) a = Image.fromarray(__lowerCamelCase ) a = {} a = predicted_depth a = depth return output_dict
330
0
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, DDIMInverseScheduler, DDIMScheduler, DPMSolverMultistepInverseScheduler, DPMSolverMultistepScheduler, StableDiffusionDiffEditPipeline, UNetaDConditionModel, ) from diffusers.utils import load_image, slow from diffusers.utils.testing_utils import enable_full_determinism, floats_tensor, require_torch_gpu, torch_device from ..pipeline_params import TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS, TEXT_GUIDED_IMAGE_INPAINTING_PARAMS from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin enable_full_determinism() class lowerCamelCase_ ( a__ , a__ , unittest.TestCase ): SCREAMING_SNAKE_CASE_ = StableDiffusionDiffEditPipeline SCREAMING_SNAKE_CASE_ = TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {'height', 'width', 'image'} | {'image_latents'} SCREAMING_SNAKE_CASE_ = TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS - {'image'} | {'image_latents'} SCREAMING_SNAKE_CASE_ = frozenset( [] ) # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess SCREAMING_SNAKE_CASE_ = frozenset([] ) def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' torch.manual_seed(0 ) a = UNetaDConditionModel( block_out_channels=(32, 64) ,layers_per_block=2 ,sample_size=32 ,in_channels=4 ,out_channels=4 ,down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''') ,up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''') ,cross_attention_dim=32 ,attention_head_dim=(2, 4) ,use_linear_projection=__lowerCamelCase ,) a = DDIMScheduler( beta_start=0.00_085 ,beta_end=0.012 ,beta_schedule='''scaled_linear''' ,clip_sample=__lowerCamelCase ,set_alpha_to_one=__lowerCamelCase ,) a = DDIMInverseScheduler( beta_start=0.00_085 ,beta_end=0.012 ,beta_schedule='''scaled_linear''' ,clip_sample=__lowerCamelCase ,set_alpha_to_zero=__lowerCamelCase ,) torch.manual_seed(0 ) a = AutoencoderKL( block_out_channels=[32, 64] ,in_channels=3 ,out_channels=3 ,down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D'''] ,up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D'''] ,latent_channels=4 ,sample_size=1_28 ,) torch.manual_seed(0 ) a = CLIPTextConfig( bos_token_id=0 ,eos_token_id=2 ,hidden_size=32 ,intermediate_size=37 ,layer_norm_eps=1e-05 ,num_attention_heads=4 ,num_hidden_layers=5 ,pad_token_id=1 ,vocab_size=10_00 ,hidden_act='''gelu''' ,projection_dim=5_12 ,) a = CLIPTextModel(__lowerCamelCase ) a = CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''' ) a = { "unet": unet, "scheduler": scheduler, "inverse_scheduler": inverse_scheduler, "vae": vae, "text_encoder": text_encoder, "tokenizer": tokenizer, "safety_checker": None, "feature_extractor": None, } return components def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : List[str] ,__lowerCamelCase : List[Any]=0 ): '''simple docstring''' a = floats_tensor((1, 16, 16) ,rng=random.Random(__lowerCamelCase ) ).to(__lowerCamelCase ) a = floats_tensor((1, 2, 4, 16, 16) ,rng=random.Random(__lowerCamelCase ) ).to(__lowerCamelCase ) if str(__lowerCamelCase ).startswith('''mps''' ): a = torch.manual_seed(__lowerCamelCase ) else: a = torch.Generator(device=__lowerCamelCase ).manual_seed(__lowerCamelCase ) a = { "prompt": "a dog and a newt", "mask_image": mask, "image_latents": latents, "generator": generator, "num_inference_steps": 2, "inpaint_strength": 1.0, "guidance_scale": 6.0, "output_type": "numpy", } return inputs def SCREAMING_SNAKE_CASE_ ( self : List[Any] ,__lowerCamelCase : Tuple ,__lowerCamelCase : Dict=0 ): '''simple docstring''' a = floats_tensor((1, 3, 32, 32) ,rng=random.Random(__lowerCamelCase ) ).to(__lowerCamelCase ) a = image.cpu().permute(0 ,2 ,3 ,1 )[0] a = Image.fromarray(np.uinta(__lowerCamelCase ) ).convert('''RGB''' ) if str(__lowerCamelCase ).startswith('''mps''' ): a = torch.manual_seed(__lowerCamelCase ) else: a = torch.Generator(device=__lowerCamelCase ).manual_seed(__lowerCamelCase ) a = { "image": image, "source_prompt": "a cat and a frog", "target_prompt": "a dog and a newt", "generator": generator, "num_inference_steps": 2, "num_maps_per_mask": 2, "mask_encode_strength": 1.0, "guidance_scale": 6.0, "output_type": "numpy", } return inputs def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : List[str] ,__lowerCamelCase : Any=0 ): '''simple docstring''' a = floats_tensor((1, 3, 32, 32) ,rng=random.Random(__lowerCamelCase ) ).to(__lowerCamelCase ) a = image.cpu().permute(0 ,2 ,3 ,1 )[0] a = Image.fromarray(np.uinta(__lowerCamelCase ) ).convert('''RGB''' ) if str(__lowerCamelCase ).startswith('''mps''' ): a = torch.manual_seed(__lowerCamelCase ) else: a = torch.Generator(device=__lowerCamelCase ).manual_seed(__lowerCamelCase ) a = { "image": image, "prompt": "a cat and a frog", "generator": generator, "num_inference_steps": 2, "inpaint_strength": 1.0, "guidance_scale": 6.0, "decode_latents": True, "output_type": "numpy", } return inputs def SCREAMING_SNAKE_CASE_ ( self : List[str] ): '''simple docstring''' if not hasattr(self.pipeline_class ,'''_optional_components''' ): return a = self.get_dummy_components() a = self.pipeline_class(**__lowerCamelCase ) pipe.to(__lowerCamelCase ) pipe.set_progress_bar_config(disable=__lowerCamelCase ) # set all optional components to None and update pipeline config accordingly for optional_component in pipe._optional_components: setattr(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ) pipe.register_modules(**{optional_component: None for optional_component in pipe._optional_components} ) a = self.get_dummy_inputs(__lowerCamelCase ) a = pipe(**__lowerCamelCase )[0] with tempfile.TemporaryDirectory() as tmpdir: pipe.save_pretrained(__lowerCamelCase ) a = self.pipeline_class.from_pretrained(__lowerCamelCase ) pipe_loaded.to(__lowerCamelCase ) pipe_loaded.set_progress_bar_config(disable=__lowerCamelCase ) for optional_component in pipe._optional_components: self.assertTrue( getattr(__lowerCamelCase ,__lowerCamelCase ) is None ,F"""`{optional_component}` did not stay set to None after loading.""" ,) a = self.get_dummy_inputs(__lowerCamelCase ) a = pipe_loaded(**__lowerCamelCase )[0] a = np.abs(output - output_loaded ).max() self.assertLess(__lowerCamelCase ,1e-4 ) def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' a = "cpu" a = self.get_dummy_components() a = self.pipeline_class(**__lowerCamelCase ) pipe.to(__lowerCamelCase ) pipe.set_progress_bar_config(disable=__lowerCamelCase ) a = self.get_dummy_mask_inputs(__lowerCamelCase ) a = pipe.generate_mask(**__lowerCamelCase ) a = mask[0, -3:, -3:] self.assertEqual(mask.shape ,(1, 16, 16) ) a = np.array([0] * 9 ) a = np.abs(mask_slice.flatten() - expected_slice ).max() self.assertLessEqual(__lowerCamelCase ,1e-3 ) self.assertEqual(mask[0, -3, -4] ,0 ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ): '''simple docstring''' a = "cpu" a = self.get_dummy_components() a = self.pipeline_class(**__lowerCamelCase ) pipe.to(__lowerCamelCase ) pipe.set_progress_bar_config(disable=__lowerCamelCase ) a = self.get_dummy_inversion_inputs(__lowerCamelCase ) a = pipe.invert(**__lowerCamelCase ).images a = image[0, -1, -3:, -3:] self.assertEqual(image.shape ,(2, 32, 32, 3) ) a = np.array( [0.5_150, 0.5_134, 0.5_043, 0.5_376, 0.4_694, 0.51_050, 0.5_015, 0.4_407, 0.4_799] ,) a = np.abs(image_slice.flatten() - expected_slice ).max() self.assertLessEqual(__lowerCamelCase ,1e-3 ) def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' super().test_inference_batch_single_identical(expected_max_diff=5e-3 ) def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' a = "cpu" a = self.get_dummy_components() a = {"beta_start": 0.00_085, "beta_end": 0.012, "beta_schedule": "scaled_linear"} a = DPMSolverMultistepScheduler(**__lowerCamelCase ) a = DPMSolverMultistepInverseScheduler(**__lowerCamelCase ) a = self.pipeline_class(**__lowerCamelCase ) pipe.to(__lowerCamelCase ) pipe.set_progress_bar_config(disable=__lowerCamelCase ) a = self.get_dummy_inversion_inputs(__lowerCamelCase ) a = pipe.invert(**__lowerCamelCase ).images a = image[0, -1, -3:, -3:] self.assertEqual(image.shape ,(2, 32, 32, 3) ) a = np.array( [0.5_150, 0.5_134, 0.5_043, 0.5_376, 0.4_694, 0.51_050, 0.5_015, 0.4_407, 0.4_799] ,) a = np.abs(image_slice.flatten() - expected_slice ).max() self.assertLessEqual(__lowerCamelCase ,1e-3 ) @require_torch_gpu @slow class lowerCamelCase_ ( unittest.TestCase ): def SCREAMING_SNAKE_CASE_ ( self : Tuple ): '''simple docstring''' super().tearDown() gc.collect() torch.cuda.empty_cache() @classmethod def SCREAMING_SNAKE_CASE_ ( cls : Optional[Any] ): '''simple docstring''' a = load_image( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/diffedit/fruit.png''' ) a = raw_image.convert('''RGB''' ).resize((7_68, 7_68) ) a = raw_image def SCREAMING_SNAKE_CASE_ ( self : List[str] ): '''simple docstring''' a = torch.manual_seed(0 ) a = StableDiffusionDiffEditPipeline.from_pretrained( '''stabilityai/stable-diffusion-2-1''' ,safety_checker=__lowerCamelCase ,torch_dtype=torch.floataa ) a = DDIMScheduler.from_config(pipe.scheduler.config ) a = DDIMInverseScheduler.from_config(pipe.scheduler.config ) pipe.enable_model_cpu_offload() pipe.set_progress_bar_config(disable=__lowerCamelCase ) a = "a bowl of fruit" a = "a bowl of pears" a = pipe.generate_mask( image=self.raw_image ,source_prompt=__lowerCamelCase ,target_prompt=__lowerCamelCase ,generator=__lowerCamelCase ,) a = pipe.invert( prompt=__lowerCamelCase ,image=self.raw_image ,inpaint_strength=0.7 ,generator=__lowerCamelCase ).latents a = pipe( prompt=__lowerCamelCase ,mask_image=__lowerCamelCase ,image_latents=__lowerCamelCase ,generator=__lowerCamelCase ,negative_prompt=__lowerCamelCase ,inpaint_strength=0.7 ,output_type='''numpy''' ,).images[0] a = ( np.array( load_image( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/diffedit/pears.png''' ).resize((7_68, 7_68) ) ) / 2_55 ) assert np.abs((expected_image - image).max() ) < 5e-1 def SCREAMING_SNAKE_CASE_ ( self : Tuple ): '''simple docstring''' a = torch.manual_seed(0 ) a = StableDiffusionDiffEditPipeline.from_pretrained( '''stabilityai/stable-diffusion-2-1''' ,safety_checker=__lowerCamelCase ,torch_dtype=torch.floataa ) a = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config ) a = DPMSolverMultistepInverseScheduler.from_config(pipe.scheduler.config ) pipe.enable_model_cpu_offload() pipe.set_progress_bar_config(disable=__lowerCamelCase ) a = "a bowl of fruit" a = "a bowl of pears" a = pipe.generate_mask( image=self.raw_image ,source_prompt=__lowerCamelCase ,target_prompt=__lowerCamelCase ,generator=__lowerCamelCase ,) a = pipe.invert( prompt=__lowerCamelCase ,image=self.raw_image ,inpaint_strength=0.7 ,generator=__lowerCamelCase ,num_inference_steps=25 ,).latents a = pipe( prompt=__lowerCamelCase ,mask_image=__lowerCamelCase ,image_latents=__lowerCamelCase ,generator=__lowerCamelCase ,negative_prompt=__lowerCamelCase ,inpaint_strength=0.7 ,num_inference_steps=25 ,output_type='''numpy''' ,).images[0] a = ( np.array( load_image( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/diffedit/pears.png''' ).resize((7_68, 7_68) ) ) / 2_55 ) assert np.abs((expected_image - image).max() ) < 5e-1
370
from dataclasses import dataclass, field from typing import ClassVar, Dict from ..features import Features, Value from .base import TaskTemplate @dataclass(frozen=a_ ) class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = field(default='language-modeling' , metadata={'include_in_asdict_even_if_is_default': True} ) SCREAMING_SNAKE_CASE_ = Features({'text': Value('string' )} ) SCREAMING_SNAKE_CASE_ = Features({} ) SCREAMING_SNAKE_CASE_ = "text" @property def SCREAMING_SNAKE_CASE_ ( self : int ): '''simple docstring''' return {self.text_column: "text"}
330
0
import os import socket from contextlib import contextmanager import torch from ..commands.config.default import write_basic_config # noqa: F401 from ..state import PartialState from .dataclasses import DistributedType from .imports import is_deepspeed_available, is_tpu_available from .transformer_engine import convert_model from .versions import is_torch_version if is_deepspeed_available(): from deepspeed import DeepSpeedEngine if is_tpu_available(check_device=False): import torch_xla.core.xla_model as xm def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> List[Any]: """simple docstring""" if is_torch_version('''<''', '''2.0.0''' ) or not hasattr(snake_case_, '''_dynamo''' ): return False return isinstance(snake_case_, torch._dynamo.eval_frame.OptimizedModule ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ = True ) -> List[str]: """simple docstring""" a = (torch.nn.parallel.DistributedDataParallel, torch.nn.DataParallel) a = is_compiled_module(snake_case_ ) if is_compiled: a = model a = model._orig_mod if is_deepspeed_available(): options += (DeepSpeedEngine,) while isinstance(snake_case_, snake_case_ ): a = model.module if not keep_fpaa_wrapper: a = getattr(snake_case_, '''forward''' ) a = model.__dict__.pop('''_original_forward''', snake_case_ ) if original_forward is not None: while hasattr(snake_case_, '''__wrapped__''' ): a = forward.__wrapped__ if forward == original_forward: break a = forward if getattr(snake_case_, '''_converted_to_transformer_engine''', snake_case_ ): convert_model(snake_case_, to_transformer_engine=snake_case_ ) if is_compiled: a = model a = compiled_model return model def SCREAMING_SNAKE_CASE__ ( ) -> Tuple: """simple docstring""" PartialState().wait_for_everyone() def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> List[str]: """simple docstring""" if PartialState().distributed_type == DistributedType.TPU: xm.save(snake_case_, snake_case_ ) elif PartialState().local_process_index == 0: torch.save(snake_case_, snake_case_ ) @contextmanager def SCREAMING_SNAKE_CASE__ ( **snake_case_ ) -> int: """simple docstring""" for key, value in kwargs.items(): a = str(snake_case_ ) yield for key in kwargs: if key.upper() in os.environ: del os.environ[key.upper()] def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> List[Any]: """simple docstring""" if not hasattr(snake_case_, '''__qualname__''' ) and not hasattr(snake_case_, '''__name__''' ): a = getattr(snake_case_, '''__class__''', snake_case_ ) if hasattr(snake_case_, '''__qualname__''' ): return obj.__qualname__ if hasattr(snake_case_, '''__name__''' ): return obj.__name__ return str(snake_case_ ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> Any: """simple docstring""" for key, value in source.items(): if isinstance(snake_case_, snake_case_ ): a = destination.setdefault(snake_case_, {} ) merge_dicts(snake_case_, snake_case_ ) else: a = value return destination def SCREAMING_SNAKE_CASE__ ( snake_case_ = None ) -> List[Any]: """simple docstring""" if port is None: a = 2_9_5_0_0 with socket.socket(socket.AF_INET, socket.SOCK_STREAM ) as s: return s.connect_ex(('''localhost''', port) ) == 0
371
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__ : Union[str, Any] = logging.get_logger(__name__) UpperCamelCase__ : Union[str, Any] = { """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_ ): SCREAMING_SNAKE_CASE_ = 'yolos' def __init__( self : Union[str, Any] ,__lowerCamelCase : int=7_68 ,__lowerCamelCase : Dict=12 ,__lowerCamelCase : Union[str, Any]=12 ,__lowerCamelCase : List[Any]=30_72 ,__lowerCamelCase : int="gelu" ,__lowerCamelCase : int=0.0 ,__lowerCamelCase : str=0.0 ,__lowerCamelCase : Optional[Any]=0.02 ,__lowerCamelCase : int=1e-12 ,__lowerCamelCase : Any=[5_12, 8_64] ,__lowerCamelCase : Tuple=16 ,__lowerCamelCase : int=3 ,__lowerCamelCase : Tuple=True ,__lowerCamelCase : Optional[int]=1_00 ,__lowerCamelCase : List[Any]=True ,__lowerCamelCase : List[str]=False ,__lowerCamelCase : int=1 ,__lowerCamelCase : List[Any]=5 ,__lowerCamelCase : Optional[int]=2 ,__lowerCamelCase : int=5 ,__lowerCamelCase : str=2 ,__lowerCamelCase : Tuple=0.1 ,**__lowerCamelCase : List[Any] ,): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = hidden_size a = num_hidden_layers a = num_attention_heads a = intermediate_size a = hidden_act a = hidden_dropout_prob a = attention_probs_dropout_prob a = initializer_range a = layer_norm_eps a = image_size a = patch_size a = num_channels a = qkv_bias a = num_detection_tokens a = use_mid_position_embeddings a = auxiliary_loss # Hungarian matcher a = class_cost a = bbox_cost a = giou_cost # Loss coefficients a = bbox_loss_coefficient a = giou_loss_coefficient a = eos_coefficient class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = version.parse('1.11' ) @property def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' return OrderedDict( [ ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}), ] ) @property def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ): '''simple docstring''' return 1e-4 @property def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' return 12
330
0
import argparse import json import os import pickle import shutil import numpy as np import torch from distiller import Distiller from lm_seqs_dataset import LmSeqsDataset from transformers import ( BertConfig, BertForMaskedLM, BertTokenizer, DistilBertConfig, DistilBertForMaskedLM, DistilBertTokenizer, GPTaConfig, GPTaLMHeadModel, GPTaTokenizer, RobertaConfig, RobertaForMaskedLM, RobertaTokenizer, ) from utils import git_log, init_gpu_params, logger, set_seed UpperCamelCase__ : List[str] = { "distilbert": (DistilBertConfig, DistilBertForMaskedLM, DistilBertTokenizer), "roberta": (RobertaConfig, RobertaForMaskedLM, RobertaTokenizer), "bert": (BertConfig, BertForMaskedLM, BertTokenizer), "gpt2": (GPTaConfig, GPTaLMHeadModel, GPTaTokenizer), } def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> str: """simple docstring""" assert (args.mlm and args.alpha_mlm > 0.0) or (not args.mlm and args.alpha_mlm == 0.0) assert (args.alpha_mlm > 0.0 and args.alpha_clm == 0.0) or (args.alpha_mlm == 0.0 and args.alpha_clm > 0.0) if args.mlm: assert os.path.isfile(args.token_counts ) assert (args.student_type in ["roberta", "distilbert"]) and (args.teacher_type in ["roberta", "bert"]) else: assert (args.student_type in ["gpt2"]) and (args.teacher_type in ["gpt2"]) assert args.teacher_type == args.student_type or ( args.student_type == "distilbert" and args.teacher_type == "bert" ) assert os.path.isfile(args.student_config ) if args.student_pretrained_weights is not None: assert os.path.isfile(args.student_pretrained_weights ) if args.freeze_token_type_embds: assert args.student_type in ["roberta"] assert args.alpha_ce >= 0.0 assert args.alpha_mlm >= 0.0 assert args.alpha_clm >= 0.0 assert args.alpha_mse >= 0.0 assert args.alpha_cos >= 0.0 assert args.alpha_ce + args.alpha_mlm + args.alpha_clm + args.alpha_mse + args.alpha_cos > 0.0 def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> int: """simple docstring""" if args.student_type == "roberta": a = False elif args.student_type == "gpt2": a = False def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> Tuple: """simple docstring""" if args.student_type == "roberta": a = False def SCREAMING_SNAKE_CASE__ ( ) -> Optional[int]: """simple docstring""" a = argparse.ArgumentParser(description='''Training''' ) parser.add_argument('''--force''', action='''store_true''', help='''Overwrite dump_path if it already exists.''' ) parser.add_argument( '''--dump_path''', type=lowerCamelCase__, required=lowerCamelCase__, help='''The output directory (log, checkpoints, parameters, etc.)''' ) parser.add_argument( '''--data_file''', type=lowerCamelCase__, required=lowerCamelCase__, help='''The binarized file (tokenized + tokens_to_ids) and grouped by sequence.''', ) parser.add_argument( '''--student_type''', type=lowerCamelCase__, choices=['''distilbert''', '''roberta''', '''gpt2'''], required=lowerCamelCase__, help='''The student type (DistilBERT, RoBERTa).''', ) parser.add_argument('''--student_config''', type=lowerCamelCase__, required=lowerCamelCase__, help='''Path to the student configuration.''' ) parser.add_argument( '''--student_pretrained_weights''', default=lowerCamelCase__, type=lowerCamelCase__, help='''Load student initialization checkpoint.''' ) parser.add_argument( '''--teacher_type''', choices=['''bert''', '''roberta''', '''gpt2'''], required=lowerCamelCase__, help='''Teacher type (BERT, RoBERTa).''' ) parser.add_argument('''--teacher_name''', type=lowerCamelCase__, required=lowerCamelCase__, help='''The teacher model.''' ) parser.add_argument('''--temperature''', default=2.0, type=lowerCamelCase__, help='''Temperature for the softmax temperature.''' ) parser.add_argument( '''--alpha_ce''', default=0.5, type=lowerCamelCase__, help='''Linear weight for the distillation loss. Must be >=0.''' ) parser.add_argument( '''--alpha_mlm''', default=0.0, type=lowerCamelCase__, help='''Linear weight for the MLM loss. Must be >=0. Should be used in conjunction with `mlm` flag.''', ) parser.add_argument('''--alpha_clm''', default=0.5, type=lowerCamelCase__, help='''Linear weight for the CLM loss. Must be >=0.''' ) parser.add_argument('''--alpha_mse''', default=0.0, type=lowerCamelCase__, help='''Linear weight of the MSE loss. Must be >=0.''' ) parser.add_argument( '''--alpha_cos''', default=0.0, type=lowerCamelCase__, help='''Linear weight of the cosine embedding loss. Must be >=0.''' ) parser.add_argument( '''--mlm''', action='''store_true''', help='''The LM step: MLM or CLM. If `mlm` is True, the MLM is used over CLM.''' ) parser.add_argument( '''--mlm_mask_prop''', default=0.15, type=lowerCamelCase__, help='''Proportion of tokens for which we need to make a prediction.''', ) parser.add_argument('''--word_mask''', default=0.8, type=lowerCamelCase__, help='''Proportion of tokens to mask out.''' ) parser.add_argument('''--word_keep''', default=0.1, type=lowerCamelCase__, help='''Proportion of tokens to keep.''' ) parser.add_argument('''--word_rand''', default=0.1, type=lowerCamelCase__, help='''Proportion of tokens to randomly replace.''' ) parser.add_argument( '''--mlm_smoothing''', default=0.7, type=lowerCamelCase__, help='''Smoothing parameter to emphasize more rare tokens (see XLM, similar to word2vec).''', ) parser.add_argument('''--token_counts''', type=lowerCamelCase__, help='''The token counts in the data_file for MLM.''' ) parser.add_argument( '''--restrict_ce_to_mask''', action='''store_true''', help='''If true, compute the distillation loss only the [MLM] prediction distribution.''', ) parser.add_argument( '''--freeze_pos_embs''', action='''store_true''', help='''Freeze positional embeddings during distillation. For student_type in [\'roberta\', \'gpt2\'] only.''', ) parser.add_argument( '''--freeze_token_type_embds''', action='''store_true''', help='''Freeze token type embeddings during distillation if existent. For student_type in [\'roberta\'] only.''', ) parser.add_argument('''--n_epoch''', type=lowerCamelCase__, default=3, help='''Number of pass on the whole dataset.''' ) parser.add_argument('''--batch_size''', type=lowerCamelCase__, default=5, help='''Batch size (for each process).''' ) parser.add_argument( '''--group_by_size''', action='''store_false''', help='''If true, group sequences that have similar length into the same batch. Default is true.''', ) parser.add_argument( '''--gradient_accumulation_steps''', type=lowerCamelCase__, default=5_0, help='''Gradient accumulation for larger training batches.''', ) parser.add_argument('''--warmup_prop''', default=0.05, type=lowerCamelCase__, help='''Linear warmup proportion.''' ) parser.add_argument('''--weight_decay''', default=0.0, type=lowerCamelCase__, help='''Weight decay if we apply some.''' ) parser.add_argument('''--learning_rate''', default=5e-4, type=lowerCamelCase__, help='''The initial learning rate for Adam.''' ) parser.add_argument('''--adam_epsilon''', default=1e-6, type=lowerCamelCase__, help='''Epsilon for Adam optimizer.''' ) parser.add_argument('''--max_grad_norm''', default=5.0, type=lowerCamelCase__, help='''Max gradient norm.''' ) parser.add_argument('''--initializer_range''', default=0.02, type=lowerCamelCase__, help='''Random initialization range.''' ) parser.add_argument( '''--fp16''', action='''store_true''', help='''Whether to use 16-bit (mixed) precision (through NVIDIA apex) instead of 32-bit''', ) parser.add_argument( '''--fp16_opt_level''', type=lowerCamelCase__, default='''O1''', help=( '''For fp16: Apex AMP optimization level selected in [\'O0\', \'O1\', \'O2\', and \'O3\'].''' '''See details at https://nvidia.github.io/apex/amp.html''' ), ) parser.add_argument('''--n_gpu''', type=lowerCamelCase__, default=1, help='''Number of GPUs in the node.''' ) parser.add_argument('''--local_rank''', type=lowerCamelCase__, default=-1, help='''Distributed training - Local rank''' ) parser.add_argument('''--seed''', type=lowerCamelCase__, default=5_6, help='''Random seed''' ) parser.add_argument('''--log_interval''', type=lowerCamelCase__, default=5_0_0, help='''Tensorboard logging interval.''' ) parser.add_argument('''--checkpoint_interval''', type=lowerCamelCase__, default=4_0_0_0, help='''Checkpoint interval.''' ) a = parser.parse_args() sanity_checks(lowerCamelCase__ ) # ARGS # init_gpu_params(lowerCamelCase__ ) set_seed(lowerCamelCase__ ) if args.is_master: if os.path.exists(args.dump_path ): if not args.force: raise ValueError( f"""Serialization dir {args.dump_path} already exists, but you have not precised wheter to overwrite""" ''' itUse `--force` if you want to overwrite it''' ) else: shutil.rmtree(args.dump_path ) if not os.path.exists(args.dump_path ): os.makedirs(args.dump_path ) logger.info(f"""Experiment will be dumped and logged in {args.dump_path}""" ) # SAVE PARAMS # logger.info(f"""Param: {args}""" ) with open(os.path.join(args.dump_path, '''parameters.json''' ), '''w''' ) as f: json.dump(vars(lowerCamelCase__ ), lowerCamelCase__, indent=4 ) git_log(args.dump_path ) a , a , a = MODEL_CLASSES[args.student_type] a , a , a = MODEL_CLASSES[args.teacher_type] # TOKENIZER # a = teacher_tokenizer_class.from_pretrained(args.teacher_name ) a = {} for tok_name, tok_symbol in tokenizer.special_tokens_map.items(): a = tokenizer.all_special_tokens.index(lowerCamelCase__ ) a = tokenizer.all_special_ids[idx] logger.info(f"""Special tokens {special_tok_ids}""" ) a = special_tok_ids a = tokenizer.max_model_input_sizes[args.teacher_name] # DATA LOADER # logger.info(f"""Loading data from {args.data_file}""" ) with open(args.data_file, '''rb''' ) as fp: a = pickle.load(lowerCamelCase__ ) if args.mlm: logger.info(f"""Loading token counts from {args.token_counts} (already pre-computed)""" ) with open(args.token_counts, '''rb''' ) as fp: a = pickle.load(lowerCamelCase__ ) a = np.maximum(lowerCamelCase__, 1 ) ** -args.mlm_smoothing for idx in special_tok_ids.values(): a = 0.0 # do not predict special tokens a = torch.from_numpy(lowerCamelCase__ ) else: a = None a = LmSeqsDataset(params=lowerCamelCase__, data=lowerCamelCase__ ) logger.info('''Data loader created.''' ) # STUDENT # logger.info(f"""Loading student config from {args.student_config}""" ) a = student_config_class.from_pretrained(args.student_config ) a = True if args.student_pretrained_weights is not None: logger.info(f"""Loading pretrained weights from {args.student_pretrained_weights}""" ) a = student_model_class.from_pretrained(args.student_pretrained_weights, config=lowerCamelCase__ ) else: a = student_model_class(lowerCamelCase__ ) if args.n_gpu > 0: student.to(f"""cuda:{args.local_rank}""" ) logger.info('''Student loaded.''' ) # TEACHER # a = teacher_model_class.from_pretrained(args.teacher_name, output_hidden_states=lowerCamelCase__ ) if args.n_gpu > 0: teacher.to(f"""cuda:{args.local_rank}""" ) logger.info(f"""Teacher loaded from {args.teacher_name}.""" ) # FREEZING # if args.freeze_pos_embs: freeze_pos_embeddings(lowerCamelCase__, lowerCamelCase__ ) if args.freeze_token_type_embds: freeze_token_type_embeddings(lowerCamelCase__, lowerCamelCase__ ) # SANITY CHECKS # assert student.config.vocab_size == teacher.config.vocab_size assert student.config.hidden_size == teacher.config.hidden_size assert student.config.max_position_embeddings == teacher.config.max_position_embeddings if args.mlm: assert token_probs.size(0 ) == stu_architecture_config.vocab_size # DISTILLER # torch.cuda.empty_cache() a = Distiller( params=lowerCamelCase__, dataset=lowerCamelCase__, token_probs=lowerCamelCase__, student=lowerCamelCase__, teacher=lowerCamelCase__ ) distiller.train() logger.info('''Let\'s go get some drinks.''' ) if __name__ == "__main__": main()
350
def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> int: """simple docstring""" a = '''''' for i in table: res += inp[i - 1] return res def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> int: """simple docstring""" return data[1:] + data[0] def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> List[str]: """simple docstring""" a = '''''' for i in range(len(snake_case_ ) ): if a[i] == b[i]: res += "0" else: res += "1" return res def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> Dict: """simple docstring""" a = int('''0b''' + data[0] + data[-1], 2 ) a = int('''0b''' + data[1:3], 2 ) return bin(s[row][col] )[2:] def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) -> Optional[int]: """simple docstring""" a = message[:4] a = message[4:] a = apply_table(snake_case_, snake_case_ ) a = xor(snake_case_, snake_case_ ) a = apply_sbox(snake_case_, temp[:4] ) # noqa: E741 a = apply_sbox(snake_case_, temp[4:] ) a = '''0''' * (2 - len(snake_case_ )) + l # noqa: E741 a = '''0''' * (2 - len(snake_case_ )) + r a = apply_table(l + r, snake_case_ ) a = xor(snake_case_, snake_case_ ) return temp + right if __name__ == "__main__": UpperCamelCase__ : int = input("""Enter 10 bit key: """) UpperCamelCase__ : Union[str, Any] = input("""Enter 8 bit message: """) UpperCamelCase__ : Dict = [6, 3, 7, 4, 8, 5, 10, 9] UpperCamelCase__ : Union[str, Any] = [3, 5, 2, 7, 4, 10, 1, 9, 8, 6] UpperCamelCase__ : Optional[int] = [2, 4, 3, 1] UpperCamelCase__ : List[Any] = [2, 6, 3, 1, 4, 8, 5, 7] UpperCamelCase__ : str = [4, 1, 3, 5, 7, 2, 8, 6] UpperCamelCase__ : List[Any] = [4, 1, 2, 3, 2, 3, 4, 1] UpperCamelCase__ : int = [[1, 0, 3, 2], [3, 2, 1, 0], [0, 2, 1, 3], [3, 1, 3, 2]] UpperCamelCase__ : Dict = [[0, 1, 2, 3], [2, 0, 1, 3], [3, 0, 1, 0], [2, 1, 0, 3]] # key generation UpperCamelCase__ : Optional[Any] = apply_table(key, paa_table) UpperCamelCase__ : str = temp[:5] UpperCamelCase__ : List[Any] = temp[5:] UpperCamelCase__ : Dict = left_shift(left) UpperCamelCase__ : Any = left_shift(right) UpperCamelCase__ : Optional[Any] = apply_table(left + right, pa_table) UpperCamelCase__ : List[str] = left_shift(left) UpperCamelCase__ : int = left_shift(right) UpperCamelCase__ : List[str] = left_shift(left) UpperCamelCase__ : Dict = left_shift(right) UpperCamelCase__ : List[str] = apply_table(left + right, pa_table) # encryption UpperCamelCase__ : Tuple = apply_table(message, IP) UpperCamelCase__ : Optional[Any] = function(expansion, sa, sa, keya, temp) UpperCamelCase__ : Optional[int] = temp[4:] + temp[:4] UpperCamelCase__ : Any = function(expansion, sa, sa, keya, temp) UpperCamelCase__ : Tuple = apply_table(temp, IP_inv) print("""Cipher text is:""", CT) # decryption UpperCamelCase__ : Union[str, Any] = apply_table(CT, IP) UpperCamelCase__ : List[str] = function(expansion, sa, sa, keya, temp) UpperCamelCase__ : Optional[Any] = temp[4:] + temp[:4] UpperCamelCase__ : Optional[int] = function(expansion, sa, sa, keya, temp) UpperCamelCase__ : Any = apply_table(temp, IP_inv) print("""Plain text after decypting is:""", PT)
330
0
from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCamelCase__ : List[Any] = logging.get_logger(__name__) UpperCamelCase__ : List[Any] = { """transfo-xl-wt103""": """https://huggingface.co/transfo-xl-wt103/resolve/main/config.json""", } class lowerCamelCase_ ( __SCREAMING_SNAKE_CASE ): SCREAMING_SNAKE_CASE_ = "transfo-xl" SCREAMING_SNAKE_CASE_ = ["mems"] SCREAMING_SNAKE_CASE_ = { "n_token": "vocab_size", "hidden_size": "d_model", "num_attention_heads": "n_head", "num_hidden_layers": "n_layer", } def __init__( self : Dict ,__lowerCamelCase : Optional[Any]=26_77_35 ,__lowerCamelCase : int=[2_00_00, 4_00_00, 20_00_00] ,__lowerCamelCase : int=10_24 ,__lowerCamelCase : Optional[int]=10_24 ,__lowerCamelCase : Optional[int]=16 ,__lowerCamelCase : Optional[Any]=64 ,__lowerCamelCase : Union[str, Any]=40_96 ,__lowerCamelCase : Dict=4 ,__lowerCamelCase : List[Any]=False ,__lowerCamelCase : Dict=18 ,__lowerCamelCase : Dict=16_00 ,__lowerCamelCase : int=10_00 ,__lowerCamelCase : Any=True ,__lowerCamelCase : List[Any]=True ,__lowerCamelCase : str=0 ,__lowerCamelCase : Optional[int]=-1 ,__lowerCamelCase : Optional[Any]=True ,__lowerCamelCase : Union[str, Any]=0.1 ,__lowerCamelCase : Any=0.0 ,__lowerCamelCase : Optional[int]=True ,__lowerCamelCase : str="normal" ,__lowerCamelCase : Optional[Any]=0.01 ,__lowerCamelCase : Optional[Any]=0.01 ,__lowerCamelCase : str=0.02 ,__lowerCamelCase : Optional[Any]=1e-5 ,__lowerCamelCase : int=0 ,**__lowerCamelCase : Optional[Any] ,): '''simple docstring''' a = vocab_size a = [] self.cutoffs.extend(_snake_case ) if proj_share_all_but_first: a = [False] + [True] * len(self.cutoffs ) else: a = [False] + [False] * len(self.cutoffs ) a = d_model a = d_embed a = d_head a = d_inner a = div_val a = pre_lnorm a = n_layer a = n_head a = mem_len a = same_length a = attn_type a = clamp_len a = sample_softmax a = adaptive a = dropout a = dropatt a = untie_r a = init a = init_range a = proj_init_std a = init_std a = layer_norm_epsilon super().__init__(eos_token_id=_snake_case ,**_snake_case ) @property def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' logger.info(F"""The model {self.model_type} is one of the few models that has no sequence length limit.""" ) return -1 @max_position_embeddings.setter def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' raise NotImplementedError( F"""The model {self.model_type} is one of the few models that has no sequence length limit.""" )
351
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 lowerCamelCase_ ( unittest.TestCase ): @slow def SCREAMING_SNAKE_CASE_ ( self : Tuple ): '''simple docstring''' a = FlaxXLMRobertaModel.from_pretrained('''xlm-roberta-base''' ) a = AutoTokenizer.from_pretrained('''xlm-roberta-base''' ) a = '''The dog is cute and lives in the garden house''' a = jnp.array([tokenizer.encode(__lowerCamelCase )] ) a = (1, 12, 7_68) # batch_size, sequence_length, embedding_vector_dim a = jnp.array( [[-0.0_101, 0.1_218, -0.0_803, 0.0_801, 0.1_327, 0.0_776, -0.1_215, 0.2_383, 0.3_338, 0.3_106, 0.0_300, 0.0_252]] ) a = model(__lowerCamelCase )['''last_hidden_state'''] self.assertEqual(output.shape ,__lowerCamelCase ) # compare the actual values for a slice of last dim self.assertTrue(jnp.allclose(output[:, :, -1] ,__lowerCamelCase ,atol=1e-3 ) )
330
0
import gc import tempfile import unittest import numpy as np import torch from diffusers import VersatileDiffusionTextToImagePipeline from diffusers.utils.testing_utils import nightly, require_torch_gpu, torch_device UpperCamelCase__ : List[str] = False class lowerCamelCase_ ( unittest.TestCase ): pass @nightly @require_torch_gpu class lowerCamelCase_ ( unittest.TestCase ): def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' super().tearDown() gc.collect() torch.cuda.empty_cache() def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' a = VersatileDiffusionTextToImagePipeline.from_pretrained('''shi-labs/versatile-diffusion''' ) # remove text_unet pipe.remove_unused_weights() pipe.to(__lowerCamelCase ) pipe.set_progress_bar_config(disable=__lowerCamelCase ) a = '''A painting of a squirrel eating a burger ''' a = torch.manual_seed(0 ) a = pipe( prompt=__lowerCamelCase ,generator=__lowerCamelCase ,guidance_scale=7.5 ,num_inference_steps=2 ,output_type='''numpy''' ).images with tempfile.TemporaryDirectory() as tmpdirname: pipe.save_pretrained(__lowerCamelCase ) a = VersatileDiffusionTextToImagePipeline.from_pretrained(__lowerCamelCase ) pipe.to(__lowerCamelCase ) pipe.set_progress_bar_config(disable=__lowerCamelCase ) a = generator.manual_seed(0 ) a = pipe( prompt=__lowerCamelCase ,generator=__lowerCamelCase ,guidance_scale=7.5 ,num_inference_steps=2 ,output_type='''numpy''' ).images assert np.abs(image - new_image ).sum() < 1e-5, "Models don't have the same forward pass" def SCREAMING_SNAKE_CASE_ ( self : List[str] ): '''simple docstring''' a = VersatileDiffusionTextToImagePipeline.from_pretrained( '''shi-labs/versatile-diffusion''' ,torch_dtype=torch.floataa ) pipe.to(__lowerCamelCase ) pipe.set_progress_bar_config(disable=__lowerCamelCase ) a = '''A painting of a squirrel eating a burger ''' a = torch.manual_seed(0 ) a = pipe( prompt=__lowerCamelCase ,generator=__lowerCamelCase ,guidance_scale=7.5 ,num_inference_steps=50 ,output_type='''numpy''' ).images a = image[0, 2_53:2_56, 2_53:2_56, -1] assert image.shape == (1, 5_12, 5_12, 3) a = np.array([0.3_367, 0.3_169, 0.2_656, 0.3_870, 0.4_790, 0.3_796, 0.4_009, 0.4_878, 0.4_778] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
352
import argparse import os # New Code # 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 import find_executable_batch_size ######################################################################## # This is a fully working simple example to use Accelerate, # specifically showcasing how to ensure out-of-memory errors never # interrupt training, and builds off the `nlp_example.py` script. # # 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) # # New additions from the base script can be found quickly by # looking for the # New Code # tags # # 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 # ######################################################################## UpperCamelCase__ : Union[str, Any] = 16 UpperCamelCase__ : Dict = 32 def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ = 1_6 ) -> Tuple: """simple docstring""" a = AutoTokenizer.from_pretrained('''bert-base-cased''' ) a = load_dataset('''glue''', '''mrpc''' ) def tokenize_function(snake_case_ ): # max_length=None => use the model max length (it's actually the default) a = 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(): a = 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 a = tokenized_datasets.rename_column('''label''', '''labels''' ) def collate_fn(snake_case_ ): # On TPU it's best to pad everything to the same length or training will be very slow. a = 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": a = 1_6 elif accelerator.mixed_precision != "no": a = 8 else: a = None return tokenizer.pad( snake_case_, padding='''longest''', max_length=snake_case_, pad_to_multiple_of=snake_case_, return_tensors='''pt''', ) # Instantiate dataloaders. a = DataLoader( tokenized_datasets['''train'''], shuffle=snake_case_, collate_fn=snake_case_, batch_size=snake_case_ ) a = 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 UpperCamelCase__ : int = mocked_dataloaders # noqa: F811 def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> List[Any]: """simple docstring""" if os.environ.get('''TESTING_MOCKED_DATALOADERS''', snake_case_ ) == "1": a = 2 # Initialize accelerator a = Accelerator(cpu=args.cpu, mixed_precision=args.mixed_precision ) # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs a = config['''lr'''] a = int(config['''num_epochs'''] ) a = int(config['''seed'''] ) a = int(config['''batch_size'''] ) a = evaluate.load('''glue''', '''mrpc''' ) # New Code # # We now can define an inner training loop function. It should take a batch size as the only parameter, # and build the dataloaders in there. # It also gets our decorator @find_executable_batch_size(starting_batch_size=snake_case_ ) def inner_training_loop(snake_case_ ): # And now just move everything below under this function # We need to bring in the Accelerator object from earlier nonlocal accelerator # And reset all of its attributes that could hold onto any memory: accelerator.free_memory() # Then we can declare the model, optimizer, and everything else: set_seed(snake_case_ ) # Instantiate the model (we build the model here so that the seed also control new weights initialization) a = 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). a = model.to(accelerator.device ) # Instantiate optimizer a = AdamW(params=model.parameters(), lr=snake_case_ ) a , a = get_dataloaders(snake_case_, snake_case_ ) # Instantiate scheduler a = 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. a , a , a , a , a = 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() 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 ) a = model(**snake_case_ ) a = outputs.loss accelerator.backward(snake_case_ ) optimizer.step() lr_scheduler.step() optimizer.zero_grad() 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(): a = model(**snake_case_ ) a = outputs.logits.argmax(dim=-1 ) a , a = accelerator.gather_for_metrics((predictions, batch['''labels''']) ) metric.add_batch( predictions=snake_case_, references=snake_case_, ) a = metric.compute() # Use accelerator.print to print only on the main process. accelerator.print(f"""epoch {epoch}:""", snake_case_ ) # New Code # # And call it at the end with no arguments # Note: You could also refactor this outside of your training loop function inner_training_loop() def SCREAMING_SNAKE_CASE__ ( ) -> Tuple: """simple docstring""" a = 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.''', ) parser.add_argument('''--cpu''', action='''store_true''', help='''If passed, will train on the CPU.''' ) a = parser.parse_args() a = {'''lr''': 2e-5, '''num_epochs''': 3, '''seed''': 4_2, '''batch_size''': 1_6} training_function(snake_case_, snake_case_ ) if __name__ == "__main__": main()
330
0
from __future__ import annotations from collections import deque class lowerCamelCase_ : def __init__( self : List[str] ,__lowerCamelCase : list[str] ): '''simple docstring''' a = [] self.adlist.append( {'''value''': '''''', '''next_states''': [], '''fail_state''': 0, '''output''': []} ) for keyword in keywords: self.add_keyword(__lowerCamelCase ) self.set_fail_transitions() def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : int ,__lowerCamelCase : str ): '''simple docstring''' for state in self.adlist[current_state]["next_states"]: if char == self.adlist[state]["value"]: return state return None def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : str ): '''simple docstring''' a = 0 for character in keyword: a = self.find_next_state(__lowerCamelCase ,__lowerCamelCase ) if next_state is None: self.adlist.append( { '''value''': character, '''next_states''': [], '''fail_state''': 0, '''output''': [], } ) self.adlist[current_state]["next_states"].append(len(self.adlist ) - 1 ) a = len(self.adlist ) - 1 else: a = next_state self.adlist[current_state]["output"].append(__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : List[str] ): '''simple docstring''' a = deque() for node in self.adlist[0]["next_states"]: q.append(__lowerCamelCase ) a = 0 while q: a = q.popleft() for child in self.adlist[r]["next_states"]: q.append(__lowerCamelCase ) a = self.adlist[r]['''fail_state'''] while ( self.find_next_state(__lowerCamelCase ,self.adlist[child]['''value'''] ) is None and state != 0 ): a = self.adlist[state]['''fail_state'''] a = self.find_next_state( __lowerCamelCase ,self.adlist[child]['''value'''] ) if self.adlist[child]["fail_state"] is None: a = 0 a = ( self.adlist[child]['''output'''] + self.adlist[self.adlist[child]['''fail_state''']]['''output'''] ) def SCREAMING_SNAKE_CASE_ ( self : List[Any] ,__lowerCamelCase : str ): '''simple docstring''' a = {} # returns a dict with keywords and list of its occurrences a = 0 for i in range(len(__lowerCamelCase ) ): while ( self.find_next_state(__lowerCamelCase ,string[i] ) is None and current_state != 0 ): a = self.adlist[current_state]['''fail_state'''] a = self.find_next_state(__lowerCamelCase ,string[i] ) if next_state is None: a = 0 else: a = next_state for key in self.adlist[current_state]["output"]: if key not in result: a = [] result[key].append(i - len(__lowerCamelCase ) + 1 ) return result if __name__ == "__main__": import doctest doctest.testmod()
353
import argparse import fairseq import torch from transformers import UniSpeechSatConfig, UniSpeechSatForCTC, UniSpeechSatForPreTraining, logging logging.set_verbosity_info() UpperCamelCase__ : Optional[int] = logging.get_logger(__name__) UpperCamelCase__ : str = { """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""", """encoder.layer_norm_for_extract""": """layer_norm_for_extract""", """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""", """label_embs_concat""": """label_embeddings_concat""", """mask_emb""": """masked_spec_embed""", """spk_proj""": """speaker_proj""", } UpperCamelCase__ : Optional[Any] = [ """lm_head""", """quantizer.weight_proj""", """quantizer.codevectors""", """project_q""", """project_hid""", """label_embeddings_concat""", """speaker_proj""", """layer_norm_for_extract""", ] def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) -> List[Any]: """simple docstring""" for attribute in key.split('''.''' ): a = getattr(snake_case_, snake_case_ ) if weight_type is not None: a = getattr(snake_case_, snake_case_ ).shape else: a = 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 = value elif weight_type == "weight_g": a = value elif weight_type == "weight_v": a = value elif weight_type == "bias": a = value else: a = value logger.info(f"""{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.""" ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> Union[str, Any]: """simple docstring""" a = [] a = fairseq_model.state_dict() a = hf_model.unispeech_sat.feature_extractor for name, value in fairseq_dict.items(): a = False if "conv_layers" in name: load_conv_layer( snake_case_, snake_case_, snake_case_, snake_case_, hf_model.config.feat_extract_norm == '''group''', ) a = True else: for key, mapped_key in MAPPING.items(): a = '''unispeech_sat.''' + 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]: if "layer_norm_for_extract" in name and (".".join(name.split('''.''' )[:-1] ) != key): # special case since naming is very similar continue a = True if "*" in mapped_key: a = name.split(snake_case_ )[0].split('''.''' )[-2] a = mapped_key.replace('''*''', snake_case_ ) if "weight_g" in name: a = '''weight_g''' elif "weight_v" in name: a = '''weight_v''' elif "bias" in name: a = '''bias''' elif "weight" in name: # TODO: don't match quantizer.weight_proj a = '''weight''' else: a = None set_recursively(snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) continue if not is_used: unused_weights.append(snake_case_ ) logger.warning(f"""Unused weights: {unused_weights}""" ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) -> Union[str, Any]: """simple docstring""" a = full_name.split('''conv_layers.''' )[-1] a = name.split('''.''' ) a = int(items[0] ) a = 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 = 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 = 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[layer_id].layer_norm.bias.data.shape} was found.""" ) a = 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[layer_id].layer_norm.weight.data.shape} was found.""" ) a = value logger.info(f"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.""" ) else: unused_weights.append(snake_case_ ) @torch.no_grad() def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_=None, snake_case_=None, snake_case_=True ) -> Union[str, Any]: """simple docstring""" if config_path is not None: a = UniSpeechSatConfig.from_pretrained(snake_case_ ) else: a = UniSpeechSatConfig() a = '''''' if is_finetuned: a = UniSpeechSatForCTC(snake_case_ ) else: a = UniSpeechSatForPreTraining(snake_case_ ) a , a , a = fairseq.checkpoint_utils.load_model_ensemble_and_task( [checkpoint_path], arg_overrides={'''data''': '''/'''.join(dict_path.split('''/''' )[:-1] )} ) a = model[0].eval() recursively_load_weights(snake_case_, snake_case_ ) hf_wavavec.save_pretrained(snake_case_ ) if __name__ == "__main__": UpperCamelCase__ : Optional[int] = argparse.ArgumentParser() parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""") parser.add_argument("""--checkpoint_path""", default=None, type=str, help="""Path to fairseq checkpoint""") parser.add_argument("""--dict_path""", default=None, type=str, help="""Path to dict of fine-tuned model""") parser.add_argument("""--config_path""", default=None, type=str, help="""Path to hf config.json of model to convert""") parser.add_argument( """--not_finetuned""", action="""store_true""", help="""Whether the model to convert is a fine-tuned model or not""" ) UpperCamelCase__ : int = parser.parse_args() convert_unispeech_sat_checkpoint( args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned )
330
0
from collections import defaultdict from math import gcd def SCREAMING_SNAKE_CASE__ ( snake_case_ = 1_5_0_0_0_0_0 ) -> int: """simple docstring""" a = defaultdict(_lowerCAmelCase ) a = 2 while 2 * euclid_m * (euclid_m + 1) <= limit: for euclid_n in range((euclid_m % 2) + 1, _lowerCAmelCase, 2 ): if gcd(_lowerCAmelCase, _lowerCAmelCase ) > 1: continue a = 2 * euclid_m * (euclid_m + euclid_n) for perimeter in range(_lowerCAmelCase, limit + 1, _lowerCAmelCase ): frequencies[perimeter] += 1 euclid_m += 1 return sum(1 for frequency in frequencies.values() if frequency == 1 ) if __name__ == "__main__": print(F"{solution() = }")
354
import pytest from datasets import inspect_metric, list_metrics, load_metric @pytest.fixture def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> List[str]: """simple docstring""" monkeypatch.setattr('''datasets.utils.deprecation_utils._emitted_deprecation_warnings''', set() ) @pytest.fixture def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Optional[int]: """simple docstring""" class lowerCamelCase_ : def __init__( self : Dict ,__lowerCamelCase : List[str] ): '''simple docstring''' a = metric_id class lowerCamelCase_ : SCREAMING_SNAKE_CASE_ = [MetricMock(a_ ) for metric_id in ['accuracy', 'mse', 'precision', 'codeparrot/apps_metric']] def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' return self._metrics monkeypatch.setattr('''datasets.inspect.huggingface_hub''', HfhMock() ) @pytest.mark.parametrize( '''func, args''', [(load_metric, ('''metrics/mse''',)), (list_metrics, ()), (inspect_metric, ('''metrics/mse''', '''tmp_path'''))] ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) -> Tuple: """simple docstring""" if "tmp_path" in args: a = tuple(arg if arg != '''tmp_path''' else tmp_path for arg in args ) with pytest.warns(snake_case_, match='''https://huggingface.co/docs/evaluate''' ): func(*snake_case_ )
330
0
"""simple docstring""" import re from filelock import FileLock try: import nltk UpperCamelCase__ : Optional[int] = True except (ImportError, ModuleNotFoundError): UpperCamelCase__ : List[str] = False if NLTK_AVAILABLE: with FileLock(""".lock""") as lock: nltk.download("""punkt""", quiet=True) def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> str: """simple docstring""" re.sub('''<n>''', '''''', snake_case_ ) # remove pegasus newline char assert NLTK_AVAILABLE, "nltk must be installed to separate newlines between sentences. (pip install nltk)" return "\n".join(nltk.sent_tokenize(snake_case_ ) )
355
from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCamelCase__ : str = logging.get_logger(__name__) UpperCamelCase__ : Optional[int] = { """studio-ousia/luke-base""": """https://huggingface.co/studio-ousia/luke-base/resolve/main/config.json""", """studio-ousia/luke-large""": """https://huggingface.co/studio-ousia/luke-large/resolve/main/config.json""", } class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = 'luke' def __init__( self : Dict ,__lowerCamelCase : Optional[Any]=5_02_67 ,__lowerCamelCase : str=50_00_00 ,__lowerCamelCase : Any=7_68 ,__lowerCamelCase : int=2_56 ,__lowerCamelCase : Optional[int]=12 ,__lowerCamelCase : Tuple=12 ,__lowerCamelCase : Any=30_72 ,__lowerCamelCase : Any="gelu" ,__lowerCamelCase : Any=0.1 ,__lowerCamelCase : Tuple=0.1 ,__lowerCamelCase : Tuple=5_12 ,__lowerCamelCase : int=2 ,__lowerCamelCase : Optional[int]=0.02 ,__lowerCamelCase : List[Any]=1e-12 ,__lowerCamelCase : Dict=True ,__lowerCamelCase : Tuple=None ,__lowerCamelCase : Any=1 ,__lowerCamelCase : Dict=0 ,__lowerCamelCase : Any=2 ,**__lowerCamelCase : str ,): '''simple docstring''' super().__init__(pad_token_id=__lowerCamelCase ,bos_token_id=__lowerCamelCase ,eos_token_id=__lowerCamelCase ,**__lowerCamelCase ) a = vocab_size a = entity_vocab_size a = hidden_size a = entity_emb_size a = num_hidden_layers a = num_attention_heads a = hidden_act a = intermediate_size a = hidden_dropout_prob a = attention_probs_dropout_prob a = max_position_embeddings a = type_vocab_size a = initializer_range a = layer_norm_eps a = use_entity_aware_attention a = classifier_dropout
330
0
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 lowerCamelCase_ ( _lowerCamelCase , unittest.TestCase ): SCREAMING_SNAKE_CASE_ = KandinskyVaaImgaImgPipeline SCREAMING_SNAKE_CASE_ = ['image_embeds', 'negative_image_embeds', 'image'] SCREAMING_SNAKE_CASE_ = [ 'image_embeds', 'negative_image_embeds', 'image', ] SCREAMING_SNAKE_CASE_ = [ 'generator', 'height', 'width', 'strength', 'guidance_scale', 'num_inference_steps', 'return_dict', 'guidance_scale', 'num_images_per_prompt', 'output_type', 'return_dict', ] SCREAMING_SNAKE_CASE_ = False @property def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' return 32 @property def SCREAMING_SNAKE_CASE_ ( self : List[str] ): '''simple docstring''' return 32 @property def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' return self.time_input_dim @property def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' return self.time_input_dim * 4 @property def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' return 1_00 @property def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' torch.manual_seed(0 ) a = { '''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, } a = UNetaDConditionModel(**lowercase_ ) return model @property def SCREAMING_SNAKE_CASE_ ( self : Any ): '''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 SCREAMING_SNAKE_CASE_ ( self : Tuple ): '''simple docstring''' torch.manual_seed(0 ) a = VQModel(**self.dummy_movq_kwargs ) return model def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' a = self.dummy_unet a = self.dummy_movq a = { '''num_train_timesteps''': 10_00, '''beta_schedule''': '''linear''', '''beta_start''': 0.00_085, '''beta_end''': 0.012, '''clip_sample''': False, '''set_alpha_to_one''': False, '''steps_offset''': 0, '''prediction_type''': '''epsilon''', '''thresholding''': False, } a = DDIMScheduler(**lowercase_ ) a = { '''unet''': unet, '''scheduler''': scheduler, '''movq''': movq, } return components def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : Dict ,__lowerCamelCase : Tuple=0 ): '''simple docstring''' a = floats_tensor((1, self.text_embedder_hidden_size) ,rng=random.Random(lowercase_ ) ).to(lowercase_ ) a = floats_tensor((1, self.text_embedder_hidden_size) ,rng=random.Random(seed + 1 ) ).to( lowercase_ ) # create init_image a = floats_tensor((1, 3, 64, 64) ,rng=random.Random(lowercase_ ) ).to(lowercase_ ) a = image.cpu().permute(0 ,2 ,3 ,1 )[0] a = Image.fromarray(np.uinta(lowercase_ ) ).convert('''RGB''' ).resize((2_56, 2_56) ) if str(lowercase_ ).startswith('''mps''' ): a = torch.manual_seed(lowercase_ ) else: a = torch.Generator(device=lowercase_ ).manual_seed(lowercase_ ) a = { '''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 SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' a = '''cpu''' a = self.get_dummy_components() a = self.pipeline_class(**lowercase_ ) a = pipe.to(lowercase_ ) pipe.set_progress_bar_config(disable=lowercase_ ) a = pipe(**self.get_dummy_inputs(lowercase_ ) ) a = output.images a = pipe( **self.get_dummy_inputs(lowercase_ ) ,return_dict=lowercase_ ,)[0] a = image[0, -3:, -3:, -1] a = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) a = np.array( [0.6_199_778, 0.63_984_406, 0.46_145_785, 0.62_944_984, 0.5_622_215, 0.47_306_132, 0.47_441_456, 0.4_607_606, 0.48_719_263] ) 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 lowerCamelCase_ ( unittest.TestCase ): def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' super().tearDown() gc.collect() torch.cuda.empty_cache() def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' a = load_numpy( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/kandinskyv22/kandinskyv22_img2img_frog.npy''' ) a = load_image( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/kandinsky/cat.png''' ) a = '''A red cartoon frog, 4k''' a = KandinskyVaaPriorPipeline.from_pretrained( '''kandinsky-community/kandinsky-2-2-prior''' ,torch_dtype=torch.floataa ) pipe_prior.to(lowercase_ ) a = KandinskyVaaImgaImgPipeline.from_pretrained( '''kandinsky-community/kandinsky-2-2-decoder''' ,torch_dtype=torch.floataa ) a = pipeline.to(lowercase_ ) pipeline.set_progress_bar_config(disable=lowercase_ ) a = torch.Generator(device='''cpu''' ).manual_seed(0 ) a , a = pipe_prior( lowercase_ ,generator=lowercase_ ,num_inference_steps=5 ,negative_prompt='''''' ,).to_tuple() a = pipeline( image=lowercase_ ,image_embeds=lowercase_ ,negative_image_embeds=lowercase_ ,generator=lowercase_ ,num_inference_steps=1_00 ,height=7_68 ,width=7_68 ,strength=0.2 ,output_type='''np''' ,) a = output.images[0] assert image.shape == (7_68, 7_68, 3) assert_mean_pixel_difference(lowercase_ ,lowercase_ )
356
import numpy as np import pandas as pd from sklearn.preprocessing import MinMaxScaler from tensorflow.keras.layers import LSTM, Dense from tensorflow.keras.models import Sequential if __name__ == "__main__": UpperCamelCase__ : Optional[int] = pd.read_csv("""sample_data.csv""", header=None) UpperCamelCase__ : Tuple = df.shape[:1][0] # If you're using some other dataset input the target column UpperCamelCase__ : List[Any] = df.iloc[:, 1:2] UpperCamelCase__ : Union[str, Any] = actual_data.values.reshape(len_data, 1) UpperCamelCase__ : List[Any] = MinMaxScaler().fit_transform(actual_data) UpperCamelCase__ : Optional[Any] = 10 UpperCamelCase__ : int = 5 UpperCamelCase__ : List[str] = 20 UpperCamelCase__ : Optional[int] = len_data - periods * look_back UpperCamelCase__ : Union[str, Any] = actual_data[:division] UpperCamelCase__ : str = actual_data[division - look_back :] UpperCamelCase__ , UpperCamelCase__ : Union[str, Any] = [], [] UpperCamelCase__ , UpperCamelCase__ : str = [], [] for i in range(0, len(train_data) - forward_days - look_back + 1): train_x.append(train_data[i : i + look_back]) train_y.append(train_data[i + look_back : i + look_back + forward_days]) for i in range(0, len(test_data) - forward_days - look_back + 1): test_x.append(test_data[i : i + look_back]) test_y.append(test_data[i + look_back : i + look_back + forward_days]) UpperCamelCase__ : List[str] = np.array(train_x) UpperCamelCase__ : Optional[Any] = np.array(test_x) UpperCamelCase__ : Tuple = np.array([list(i.ravel()) for i in train_y]) UpperCamelCase__ : Optional[Any] = np.array([list(i.ravel()) for i in test_y]) UpperCamelCase__ : Union[str, Any] = Sequential() model.add(LSTM(128, input_shape=(look_back, 1), return_sequences=True)) model.add(LSTM(64, input_shape=(128, 1))) model.add(Dense(forward_days)) model.compile(loss="""mean_squared_error""", optimizer="""adam""") UpperCamelCase__ : Tuple = model.fit( x_train, y_train, epochs=150, verbose=1, shuffle=True, batch_size=4 ) UpperCamelCase__ : Tuple = model.predict(x_test)
330
0
def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> int: """simple docstring""" a = hex_num.strip() if not hex_num: raise ValueError('''No value was passed to the function''' ) a = hex_num[0] == '''-''' if is_negative: a = hex_num[1:] try: a = int(lowercase_, 1_6 ) except ValueError: raise ValueError('''Invalid value was passed to the function''' ) a = '''''' while int_num > 0: a = str(int_num % 2 ) + bin_str int_num >>= 1 return int(('''-''' + bin_str) if is_negative else bin_str ) if __name__ == "__main__": import doctest doctest.testmod()
357
import os import time import pytest from datasets.utils.filelock import FileLock, Timeout def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Tuple: """simple docstring""" a = FileLock(str(tmpdir / '''foo.lock''' ) ) a = FileLock(str(tmpdir / '''foo.lock''' ) ) a = 0.01 with locka.acquire(): with pytest.raises(snake_case_ ): a = time.time() locka.acquire(snake_case_ ) assert time.time() - _start > timeout def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Optional[int]: """simple docstring""" a = '''a''' * 1_0_0_0 + '''.lock''' a = FileLock(str(tmpdir / filename ) ) assert locka._lock_file.endswith('''.lock''' ) assert not locka._lock_file.endswith(snake_case_ ) assert len(os.path.basename(locka._lock_file ) ) <= 2_5_5 a = FileLock(tmpdir / filename ) with locka.acquire(): with pytest.raises(snake_case_ ): locka.acquire(0 )
330
0
from .glue import GlueDataset, GlueDataTrainingArguments from .language_modeling import ( LineByLineTextDataset, LineByLineWithRefDataset, LineByLineWithSOPTextDataset, TextDataset, TextDatasetForNextSentencePrediction, ) from .squad import SquadDataset, SquadDataTrainingArguments
358
from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCamelCase__ : Optional[int] = logging.get_logger(__name__) UpperCamelCase__ : Dict = { """facebook/vit-mae-base""": """https://huggingface.co/facebook/vit-mae-base/resolve/main/config.json""", # See all ViT MAE models at https://huggingface.co/models?filter=vit-mae } class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = 'vit_mae' def __init__( self : Dict ,__lowerCamelCase : Any=7_68 ,__lowerCamelCase : Optional[Any]=12 ,__lowerCamelCase : List[str]=12 ,__lowerCamelCase : Optional[int]=30_72 ,__lowerCamelCase : int="gelu" ,__lowerCamelCase : Union[str, Any]=0.0 ,__lowerCamelCase : Optional[int]=0.0 ,__lowerCamelCase : Dict=0.02 ,__lowerCamelCase : List[Any]=1e-12 ,__lowerCamelCase : Dict=2_24 ,__lowerCamelCase : str=16 ,__lowerCamelCase : Union[str, Any]=3 ,__lowerCamelCase : Optional[Any]=True ,__lowerCamelCase : Dict=16 ,__lowerCamelCase : List[str]=5_12 ,__lowerCamelCase : int=8 ,__lowerCamelCase : int=20_48 ,__lowerCamelCase : Optional[Any]=0.75 ,__lowerCamelCase : int=False ,**__lowerCamelCase : Any ,): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = hidden_size a = num_hidden_layers a = num_attention_heads a = intermediate_size a = hidden_act a = hidden_dropout_prob a = attention_probs_dropout_prob a = initializer_range a = layer_norm_eps a = image_size a = patch_size a = num_channels a = qkv_bias a = decoder_num_attention_heads a = decoder_hidden_size a = decoder_num_hidden_layers a = decoder_intermediate_size a = mask_ratio a = norm_pix_loss
330
0
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_tokenizers_available, is_torch_available, ) UpperCamelCase__ : Optional[Any] = { """configuration_lxmert""": ["""LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """LxmertConfig"""], """tokenization_lxmert""": ["""LxmertTokenizer"""], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCamelCase__ : Dict = ["""LxmertTokenizerFast"""] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCamelCase__ : str = [ """LxmertEncoder""", """LxmertForPreTraining""", """LxmertForQuestionAnswering""", """LxmertModel""", """LxmertPreTrainedModel""", """LxmertVisualFeatureEncoder""", """LxmertXLayer""", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCamelCase__ : List[str] = [ """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 UpperCamelCase__ : Union[str, Any] = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
359
def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Union[str, Any]: """simple docstring""" stooge(snake_case_, 0, len(snake_case_ ) - 1 ) return arr def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> Optional[Any]: """simple docstring""" if i >= h: return # If first element is smaller than the last then swap them if arr[i] > arr[h]: a , a = arr[h], arr[i] # If there are more than 2 elements in the array if h - i + 1 > 2: a = (int)((h - i + 1) / 3 ) # Recursively sort first 2/3 elements stooge(snake_case_, snake_case_, (h - t) ) # Recursively sort last 2/3 elements stooge(snake_case_, i + t, (snake_case_) ) # Recursively sort first 2/3 elements stooge(snake_case_, snake_case_, (h - t) ) if __name__ == "__main__": UpperCamelCase__ : Dict = input("""Enter numbers separated by a comma:\n""").strip() UpperCamelCase__ : Optional[int] = [int(item) for item in user_input.split(""",""")] print(stooge_sort(unsorted))
330
0
from __future__ import annotations import os import tempfile import unittest import numpy as np from huggingface_hub import hf_hub_download from transformers import is_tensorflow_text_available, is_tf_available from transformers.testing_utils import require_tensorflow_text, require_tf, slow from ..test_modeling_tf_common import floats_tensor from .test_framework_agnostic import GenerationIntegrationTestsMixin if is_tf_available(): import tensorflow as tf from transformers import ( AutoTokenizer, TFAutoModelForCausalLM, TFAutoModelForSeqaSeqLM, TFAutoModelForSpeechSeqaSeq, TFAutoModelForVisionaSeq, TFBartForConditionalGeneration, TFLogitsProcessorList, TFMinLengthLogitsProcessor, tf_top_k_top_p_filtering, ) if is_tensorflow_text_available(): import tensorflow_text as text @require_tf class lowerCamelCase_ ( unittest.TestCase ): def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' a = tf.convert_to_tensor( [ [ 8.2_220_991, # 3rd highest value; idx. 0 -0.5_620_044, 5.23_229_752, 4.0_386_393, -6.8_798_378, -0.54_785_802, -3.2_012_153, 2.92_777_176, 1.88_171_953, 7.35_341_276, # 5th highest value; idx. 9 8.43_207_833, # 2nd highest value; idx. 10 -9.85_711_836, -5.96_209_236, -1.13_039_161, -7.1_115_294, -0.8_369_633, -5.3_186_408, 7.06_427_407, 0.81_369_344, -0.82_023_817, -5.9_179_796, 0.58_813_443, -6.99_778_438, 4.71_551_189, -0.18_771_637, 7.44_020_759, # 4th highest value; idx. 25 9.38_450_987, # 1st highest value; idx. 26 2.12_662_941, -9.32_562_038, 2.35_652_522, ], # cummulative prob of 5 highest values <= 0.6 [ 0.58_425_518, 4.53_139_238, -5.57_510_464, -6.28_030_699, -7.19_529_503, -4.02_122_551, 1.39_337_037, -6.06_707_057, 1.59_480_517, -9.643_119, 0.03_907_799, 0.67_231_762, -8.88_206_726, 6.27_115_922, # 4th highest value; idx. 13 2.28_520_723, 4.82_767_506, 4.30_421_368, 8.8_275_313, # 2nd highest value; idx. 17 5.44_029_958, # 5th highest value; idx. 18 -4.4_735_794, 7.38_579_536, # 3rd highest value; idx. 20 -2.91_051_663, 2.61_946_077, -2.5_674_762, -9.48_959_302, -4.02_922_645, -1.35_416_918, 9.67_702_323, # 1st highest value; idx. 27 -5.89_478_553, 1.85_370_467, ], # cummulative prob of 5 highest values <= 0.6 ] ,dtype=tf.floataa ,) a = tf.convert_to_tensor( [[0, 0], [0, 9], [0, 10], [0, 25], [0, 26], [1, 13], [1, 17], [1, 18], [1, 20], [1, 27]] ,dtype=tf.intaa ,) # expected non filtered idx as noted above a = tf.convert_to_tensor( [8.222_099, 7.3_534_126, 8.432_078, 7.4_402_075, 9.38_451, 6.271_159, 8.827_531, 5.4_402_995, 7.3_857_956, 9.677_023] ,dtype=tf.floataa ,) # expected non filtered values as noted above a = tf_top_k_top_p_filtering(_SCREAMING_SNAKE_CASE ,top_k=10 ,top_p=0.6 ,min_tokens_to_keep=4 ) a = output[output != -float('''inf''' )] a = tf.cast( tf.where(tf.not_equal(_SCREAMING_SNAKE_CASE ,tf.constant(-float('''inf''' ) ,dtype=tf.floataa ) ) ) ,dtype=tf.intaa ,) tf.debugging.assert_near(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,rtol=1e-12 ) tf.debugging.assert_equal(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ) @require_tf class lowerCamelCase_ ( unittest.TestCase , UpperCAmelCase__ ): # setting framework_dependent_parameters needs to be gated, just like its contents' imports if is_tf_available(): SCREAMING_SNAKE_CASE_ = { 'AutoModelForCausalLM': TFAutoModelForCausalLM, 'AutoModelForSpeechSeq2Seq': TFAutoModelForSpeechSeqaSeq, 'AutoModelForSeq2SeqLM': TFAutoModelForSeqaSeqLM, 'AutoModelForVision2Seq': TFAutoModelForVisionaSeq, 'LogitsProcessorList': TFLogitsProcessorList, 'MinLengthLogitsProcessor': TFMinLengthLogitsProcessor, 'create_tensor_fn': tf.convert_to_tensor, 'floats_tensor': floats_tensor, 'return_tensors': 'tf', } @slow def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' a = TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2''' ) a = 2 a = 2 class lowerCamelCase_ ( tf.Module ): def __init__( self : str ,__lowerCamelCase : int ): '''simple docstring''' super(_SCREAMING_SNAKE_CASE ,self ).__init__() a = model @tf.function( input_signature=( tf.TensorSpec((None, input_length) ,tf.intaa ,name='''input_ids''' ), tf.TensorSpec((None, input_length) ,tf.intaa ,name='''attention_mask''' ), ) ,jit_compile=_SCREAMING_SNAKE_CASE ,) def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : List[Any] ,__lowerCamelCase : int ): '''simple docstring''' a = self.model.generate( input_ids=_SCREAMING_SNAKE_CASE ,attention_mask=_SCREAMING_SNAKE_CASE ,max_new_tokens=_SCREAMING_SNAKE_CASE ,return_dict_in_generate=_SCREAMING_SNAKE_CASE ,) return {"sequences": outputs["sequences"]} a = [[2, 0], [1_02, 1_03]] a = [[1, 0], [1, 1]] a = DummyModel(model=_SCREAMING_SNAKE_CASE ) with tempfile.TemporaryDirectory() as tmp_dir: tf.saved_model.save(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,signatures={'''serving_default''': dummy_model.serving} ) a = tf.saved_model.load(_SCREAMING_SNAKE_CASE ).signatures["""serving_default"""] for batch_size in range(1 ,len(_SCREAMING_SNAKE_CASE ) + 1 ): a = { """input_ids""": tf.constant(dummy_input_ids[:batch_size] ), """attention_mask""": tf.constant(dummy_attention_masks[:batch_size] ), } a = serving_func(**_SCREAMING_SNAKE_CASE )["""sequences"""] a = test_model.generate(**_SCREAMING_SNAKE_CASE ,max_new_tokens=_SCREAMING_SNAKE_CASE ) tf.debugging.assert_equal(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ) @slow def SCREAMING_SNAKE_CASE_ ( self : List[str] ): '''simple docstring''' a = TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2''' ) a = 1 a = 2 class lowerCamelCase_ ( tf.Module ): def __init__( self : Dict ,__lowerCamelCase : Tuple ): '''simple docstring''' super(_SCREAMING_SNAKE_CASE ,self ).__init__() a = model @tf.function( input_signature=( tf.TensorSpec((batch_size, None) ,tf.intaa ,name='''input_ids''' ), tf.TensorSpec((batch_size, None) ,tf.intaa ,name='''attention_mask''' ), ) ,jit_compile=_SCREAMING_SNAKE_CASE ,) def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : Optional[int] ): '''simple docstring''' a = self.model.generate( input_ids=_SCREAMING_SNAKE_CASE ,attention_mask=_SCREAMING_SNAKE_CASE ,max_new_tokens=_SCREAMING_SNAKE_CASE ,return_dict_in_generate=_SCREAMING_SNAKE_CASE ,) return {"sequences": outputs["sequences"]} a = [[2], [1_02, 1_03]] a = [[1], [1, 1]] a = DummyModel(model=_SCREAMING_SNAKE_CASE ) with tempfile.TemporaryDirectory() as tmp_dir: tf.saved_model.save(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,signatures={'''serving_default''': dummy_model.serving} ) a = tf.saved_model.load(_SCREAMING_SNAKE_CASE ).signatures["""serving_default"""] for input_row in range(len(_SCREAMING_SNAKE_CASE ) ): a = { """input_ids""": tf.constant([dummy_input_ids[input_row]] ), """attention_mask""": tf.constant([dummy_attention_masks[input_row]] ), } a = serving_func(**_SCREAMING_SNAKE_CASE )["""sequences"""] a = test_model.generate(**_SCREAMING_SNAKE_CASE ,max_new_tokens=_SCREAMING_SNAKE_CASE ) tf.debugging.assert_equal(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ) @slow @require_tensorflow_text def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' with tempfile.TemporaryDirectory() as tmp_dir: # file needed to load the TF tokenizer hf_hub_download(repo_id='''google/flan-t5-small''' ,filename='''spiece.model''' ,local_dir=_SCREAMING_SNAKE_CASE ) class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : str ): '''simple docstring''' super().__init__() a = text.SentencepieceTokenizer( model=tf.io.gfile.GFile(os.path.join(_SCREAMING_SNAKE_CASE ,'''spiece.model''' ) ,'''rb''' ).read() ) a = TFAutoModelForSeqaSeqLM.from_pretrained('''hf-internal-testing/tiny-random-t5''' ) def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : Optional[Any] ,*__lowerCamelCase : Tuple ,**__lowerCamelCase : Optional[int] ): '''simple docstring''' a = self.tokenizer.tokenize(_SCREAMING_SNAKE_CASE ) a = text.pad_model_inputs( _SCREAMING_SNAKE_CASE ,max_seq_length=64 ,pad_value=self.model.config.pad_token_id ) a = self.model.generate(input_ids=_SCREAMING_SNAKE_CASE ,attention_mask=_SCREAMING_SNAKE_CASE ) return self.tokenizer.detokenize(_SCREAMING_SNAKE_CASE ) a = CompleteSentenceTransformer() a = tf.keras.layers.Input(shape=(1,) ,dtype=tf.string ,name='''inputs''' ) a = complete_model(_SCREAMING_SNAKE_CASE ) a = tf.keras.Model(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ) keras_model.save(_SCREAMING_SNAKE_CASE ) def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' a = { """do_sample""": True, """num_beams""": 1, """top_p""": 0.7, """top_k""": 10, """temperature""": 0.7, } a = 14 a = AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-gpt2''' ) a = """Hello, my dog is cute and""" a = tokenizer(_SCREAMING_SNAKE_CASE ,return_tensors='''tf''' ) a = TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2''' ) a = 6_38 # forces the generation to happen on CPU, to avoid GPU-related quirks with tf.device(''':/CPU:0''' ): tf.random.set_seed(0 ) a = model.generate(**_SCREAMING_SNAKE_CASE ,eos_token_id=_SCREAMING_SNAKE_CASE ,**_SCREAMING_SNAKE_CASE ) self.assertTrue(expectation == len(generated_tokens[0] ) ) a = [6_38, 1_98] with tf.device(''':/CPU:0''' ): tf.random.set_seed(0 ) a = model.generate(**_SCREAMING_SNAKE_CASE ,eos_token_id=_SCREAMING_SNAKE_CASE ,**_SCREAMING_SNAKE_CASE ) self.assertTrue(expectation == len(generated_tokens[0] ) ) def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' a = AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bart''' ) a = """Hugging Face is a technology company based in New York and Paris.""" a = bart_tokenizer(_SCREAMING_SNAKE_CASE ,return_tensors='''tf''' ).input_ids a = TFBartForConditionalGeneration.from_pretrained('''hf-internal-testing/tiny-random-bart''' ) a = bart_model.generate(_SCREAMING_SNAKE_CASE ).numpy() class lowerCamelCase_ ( UpperCAmelCase__ ): def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ,__lowerCamelCase : str ,__lowerCamelCase : Dict=None ,**__lowerCamelCase : List[Any] ): '''simple docstring''' return super().call(_SCREAMING_SNAKE_CASE ,**_SCREAMING_SNAKE_CASE ) a = FakeBart.from_pretrained('''hf-internal-testing/tiny-random-bart''' ) a = bart_model.generate(_SCREAMING_SNAKE_CASE ,foo='''bar''' ).numpy() self.assertTrue(np.array_equal(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ) ) class lowerCamelCase_ ( bart_model.model.encoder.__class__ ): def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : Optional[Any] ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' return super().call(_SCREAMING_SNAKE_CASE ,**_SCREAMING_SNAKE_CASE ) a = FakeEncoder(bart_model.config ,bart_model.model.shared ) a = fake_encoder # Normal generation still works (the output will be different because the encoder weights are different) a = bart_model.generate(_SCREAMING_SNAKE_CASE ).numpy() with self.assertRaises(_SCREAMING_SNAKE_CASE ): # FakeEncoder.call() accepts **kwargs -> no filtering -> value error due to unexpected input "foo" bart_model.generate(_SCREAMING_SNAKE_CASE ,foo='''bar''' )
360
import json import os import re import unicodedata from json.encoder import INFINITY from typing import Any, Dict, List, Optional, Tuple, Union import numpy as np import regex from ...tokenization_utils import AddedToken, PreTrainedTokenizer from ...tokenization_utils_base import BatchEncoding from ...utils import TensorType, is_flax_available, is_tf_available, is_torch_available, logging from ...utils.generic import _is_jax, _is_numpy UpperCamelCase__ : Any = logging.get_logger(__name__) UpperCamelCase__ : Optional[Any] = { """artists_file""": """artists.json""", """lyrics_file""": """lyrics.json""", """genres_file""": """genres.json""", } UpperCamelCase__ : Union[str, Any] = { """artists_file""": { """jukebox""": """https://huggingface.co/ArthurZ/jukebox/blob/main/artists.json""", }, """genres_file""": { """jukebox""": """https://huggingface.co/ArthurZ/jukebox/blob/main/genres.json""", }, """lyrics_file""": { """jukebox""": """https://huggingface.co/ArthurZ/jukebox/blob/main/lyrics.json""", }, } UpperCamelCase__ : str = { """jukebox""": 512, } class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = VOCAB_FILES_NAMES SCREAMING_SNAKE_CASE_ = PRETRAINED_VOCAB_FILES_MAP SCREAMING_SNAKE_CASE_ = PRETRAINED_LYRIC_TOKENS_SIZES SCREAMING_SNAKE_CASE_ = ['input_ids', 'attention_mask'] def __init__( self : Optional[Any] ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : List[Any] ,__lowerCamelCase : Tuple ,__lowerCamelCase : Union[str, Any]=["v3", "v2", "v2"] ,__lowerCamelCase : List[Any]=5_12 ,__lowerCamelCase : Tuple=5 ,__lowerCamelCase : List[Any]="<|endoftext|>" ,**__lowerCamelCase : List[str] ,): '''simple docstring''' a = AddedToken(__lowerCamelCase ,lstrip=__lowerCamelCase ,rstrip=__lowerCamelCase ) if isinstance(__lowerCamelCase ,__lowerCamelCase ) else unk_token super().__init__( unk_token=__lowerCamelCase ,n_genres=__lowerCamelCase ,version=__lowerCamelCase ,max_n_lyric_tokens=__lowerCamelCase ,**__lowerCamelCase ,) a = version a = max_n_lyric_tokens a = n_genres with open(__lowerCamelCase ,encoding='''utf-8''' ) as vocab_handle: a = json.load(__lowerCamelCase ) with open(__lowerCamelCase ,encoding='''utf-8''' ) as vocab_handle: a = json.load(__lowerCamelCase ) with open(__lowerCamelCase ,encoding='''utf-8''' ) as vocab_handle: a = json.load(__lowerCamelCase ) a = r'''[^A-Za-z0-9.,:;!?\-\'\"()\[\] \t\n]+''' # In v2, we had a n_vocab=80 and in v3 we missed + and so n_vocab=79 of characters. if len(self.lyrics_encoder ) == 79: a = oov.replace(r'''\-\'''' ,r'''\-+\'''' ) a = regex.compile(__lowerCamelCase ) a = {v: k for k, v in self.artists_encoder.items()} a = {v: k for k, v in self.genres_encoder.items()} a = {v: k for k, v in self.lyrics_encoder.items()} @property def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' return len(self.artists_encoder ) + len(self.genres_encoder ) + len(self.lyrics_encoder ) def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ): '''simple docstring''' return dict(self.artists_encoder ,self.genres_encoder ,self.lyrics_encoder ) def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : Optional[int] ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : List[Any] ): '''simple docstring''' a = [self.artists_encoder.get(__lowerCamelCase ,0 ) for artist in list_artists] for genres in range(len(__lowerCamelCase ) ): a = [self.genres_encoder.get(__lowerCamelCase ,0 ) for genre in list_genres[genres]] a = list_genres[genres] + [-1] * (self.n_genres - len(list_genres[genres] )) a = [[self.lyrics_encoder.get(__lowerCamelCase ,0 ) for character in list_lyrics[0]], [], []] return artists_id, list_genres, lyric_ids def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : List[str] ): '''simple docstring''' return list(__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : List[Any] ,__lowerCamelCase : Any ,__lowerCamelCase : Optional[int] ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' a , a , a = self.prepare_for_tokenization(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ) a = self._tokenize(__lowerCamelCase ) return artist, genre, lyrics def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : str ,__lowerCamelCase : str ,__lowerCamelCase : str ,__lowerCamelCase : bool = False ): '''simple docstring''' for idx in range(len(self.version ) ): if self.version[idx] == "v3": a = artists[idx].lower() a = [genres[idx].lower()] else: a = self._normalize(artists[idx] ) + '''.v2''' a = [ self._normalize(__lowerCamelCase ) + '''.v2''' for genre in genres[idx].split('''_''' ) ] # split is for the full dictionary with combined genres if self.version[0] == "v2": a = regex.compile(r'''[^A-Za-z0-9.,:;!?\-\'\"()\[\] \t\n]+''' ) a = '''ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.,:;!?-+\'\"()[] \t\n''' a = {vocab[index]: index + 1 for index in range(len(__lowerCamelCase ) )} a = 0 a = len(__lowerCamelCase ) + 1 a = self.vocab a = {v: k for k, v in self.vocab.items()} a = '''''' else: a = regex.compile(r'''[^A-Za-z0-9.,:;!?\-+\'\"()\[\] \t\n]+''' ) a = self._run_strip_accents(__lowerCamelCase ) a = lyrics.replace('''\\''' ,'''\n''' ) a = self.out_of_vocab.sub('''''' ,__lowerCamelCase ), [], [] return artists, genres, lyrics def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : int ): '''simple docstring''' a = unicodedata.normalize('''NFD''' ,__lowerCamelCase ) a = [] for char in text: a = unicodedata.category(__lowerCamelCase ) if cat == "Mn": continue output.append(__lowerCamelCase ) return "".join(__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : str ): '''simple docstring''' a = ( [chr(__lowerCamelCase ) for i in range(ord('''a''' ) ,ord('''z''' ) + 1 )] + [chr(__lowerCamelCase ) for i in range(ord('''A''' ) ,ord('''Z''' ) + 1 )] + [chr(__lowerCamelCase ) for i in range(ord('''0''' ) ,ord('''9''' ) + 1 )] + ['''.'''] ) a = frozenset(__lowerCamelCase ) a = re.compile(r'''_+''' ) a = ''''''.join([c if c in accepted else '''_''' for c in text.lower()] ) a = pattern.sub('''_''' ,__lowerCamelCase ).strip('''_''' ) return text def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : List[str] ): '''simple docstring''' return " ".join(__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : str ,__lowerCamelCase : Optional[Union[str, TensorType]] = None ,__lowerCamelCase : bool = False ): '''simple docstring''' if not isinstance(__lowerCamelCase ,__lowerCamelCase ): a = TensorType(__lowerCamelCase ) # Get a function reference for the correct framework if tensor_type == TensorType.TENSORFLOW: if not is_tf_available(): raise ImportError( '''Unable to convert output to TensorFlow tensors format, TensorFlow is not installed.''' ) import tensorflow as tf a = tf.constant a = tf.is_tensor elif tensor_type == TensorType.PYTORCH: if not is_torch_available(): raise ImportError('''Unable to convert output to PyTorch tensors format, PyTorch is not installed.''' ) import torch a = torch.tensor a = torch.is_tensor elif tensor_type == TensorType.JAX: if not is_flax_available(): raise ImportError('''Unable to convert output to JAX tensors format, JAX is not installed.''' ) import jax.numpy as jnp # noqa: F811 a = jnp.array a = _is_jax else: a = np.asarray a = _is_numpy # Do the tensor conversion in batch try: if prepend_batch_axis: a = [inputs] if not is_tensor(__lowerCamelCase ): a = as_tensor(__lowerCamelCase ) except: # noqa E722 raise ValueError( '''Unable to create tensor, you should probably activate truncation and/or padding ''' '''with \'padding=True\' \'truncation=True\' to have batched tensors with the same length.''' ) return inputs def __call__( self : Tuple ,__lowerCamelCase : Tuple ,__lowerCamelCase : Optional[int] ,__lowerCamelCase : List[str]="" ,__lowerCamelCase : List[Any]="pt" ): '''simple docstring''' a = [0, 0, 0] a = [artist] * len(self.version ) a = [genres] * len(self.version ) a , a , a = self.tokenize(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ) a , a , a = self._convert_token_to_id(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ) a = [-INFINITY] * len(full_tokens[-1] ) a = [ self.convert_to_tensors( [input_ids + [artists_id[i]] + genres_ids[i] + full_tokens[i]] ,tensor_type=__lowerCamelCase ) for i in range(len(self.version ) ) ] return BatchEncoding({'''input_ids''': input_ids, '''attention_masks''': attention_masks} ) def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : str ,__lowerCamelCase : Optional[str] = None ): '''simple docstring''' if not os.path.isdir(__lowerCamelCase ): logger.error(F"""Vocabulary path ({save_directory}) should be a directory""" ) return a = os.path.join( __lowerCamelCase ,(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''artists_file'''] ) with open(__lowerCamelCase ,'''w''' ,encoding='''utf-8''' ) as f: f.write(json.dumps(self.artists_encoder ,ensure_ascii=__lowerCamelCase ) ) a = os.path.join( __lowerCamelCase ,(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''genres_file'''] ) with open(__lowerCamelCase ,'''w''' ,encoding='''utf-8''' ) as f: f.write(json.dumps(self.genres_encoder ,ensure_ascii=__lowerCamelCase ) ) a = os.path.join( __lowerCamelCase ,(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''lyrics_file'''] ) with open(__lowerCamelCase ,'''w''' ,encoding='''utf-8''' ) as f: f.write(json.dumps(self.lyrics_encoder ,ensure_ascii=__lowerCamelCase ) ) return (artists_file, genres_file, lyrics_file) def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : Any ,__lowerCamelCase : Any ,__lowerCamelCase : str ): '''simple docstring''' a = self.artists_decoder.get(__lowerCamelCase ) a = [self.genres_decoder.get(__lowerCamelCase ) for genre in genres_index] a = [self.lyrics_decoder.get(__lowerCamelCase ) for character in lyric_index] return artist, genres, lyrics
330
0
import logging import numpy as np import pytest from scipy.linalg import eigh logging.basicConfig(level=logging.INFO, format="""%(message)s""") def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Optional[Any]: """simple docstring""" return input_array.reshape((input_array.size, 1) ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> int: """simple docstring""" a = np.nan for i in range(_a ): a = features[:, labels == i] a = data.mean(1 ) # Centralize the data of class i a = data - column_reshape(_a ) if i > 0: # If covariance_sum is not None covariance_sum += np.dot(_a, centered_data.T ) else: # If covariance_sum is np.nan (i.e. first loop) a = np.dot(_a, centered_data.T ) return covariance_sum / features.shape[1] def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> Optional[Any]: """simple docstring""" a = features.mean(1 ) a = np.nan for i in range(_a ): a = features[:, labels == i] a = data.shape[1] a = data.mean(1 ) if i > 0: # If covariance_sum is not None covariance_sum += device_data * np.dot( column_reshape(_a ) - column_reshape(_a ), (column_reshape(_a ) - column_reshape(_a )).T, ) else: # If covariance_sum is np.nan (i.e. first loop) a = device_data * np.dot( column_reshape(_a ) - column_reshape(_a ), (column_reshape(_a ) - column_reshape(_a )).T, ) return covariance_sum / features.shape[1] def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> str: """simple docstring""" if features.any(): a = features.mean(1 ) # Center the dataset a = features - np.reshape(_a, (data_mean.size, 1) ) a = np.dot(_a, centered_data.T ) / features.shape[1] a , a = np.linalg.eigh(_a ) # Take all the columns in the reverse order (-1), and then takes only the first a = eigenvectors[:, ::-1][:, 0:dimensions] # Project the database on the new space a = np.dot(filtered_eigenvectors.T, _a ) logging.info('''Principal Component Analysis computed''' ) return projected_data else: logging.basicConfig(level=logging.ERROR, format='''%(message)s''', force=_a ) logging.error('''Dataset empty''' ) raise AssertionError def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_ ) -> Union[str, Any]: """simple docstring""" assert classes > dimensions # Check if features have been already loaded if features.any: a , a = eigh( covariance_between_classes(_a, _a, _a ), covariance_within_classes(_a, _a, _a ), ) a = eigenvectors[:, ::-1][:, :dimensions] a , a , a = np.linalg.svd(_a ) a = svd_matrix[:, 0:dimensions] a = np.dot(filtered_svd_matrix.T, _a ) logging.info('''Linear Discriminant Analysis computed''' ) return projected_data else: logging.basicConfig(level=logging.ERROR, format='''%(message)s''', force=_a ) logging.error('''Dataset empty''' ) raise AssertionError def SCREAMING_SNAKE_CASE__ ( ) -> Union[str, Any]: """simple docstring""" a = np.array([[1, 2, 3, 4, 5], [2, 3, 4, 5, 6], [3, 4, 5, 6, 7]] ) a = np.array([0, 0, 0, 1, 1] ) a = 2 a = 2 # Assert that the function raises an AssertionError if dimensions > classes with pytest.raises(_a ) as error_info: a = linear_discriminant_analysis( _a, _a, _a, _a ) if isinstance(_a, np.ndarray ): raise AssertionError( '''Did not raise AssertionError for dimensions > classes''' ) assert error_info.type is AssertionError def SCREAMING_SNAKE_CASE__ ( ) -> Tuple: """simple docstring""" a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]] ) a = 2 a = np.array([[6.9282_0323, 8.6602_5404, 10.3923_0485], [3.0, 3.0, 3.0]] ) with pytest.raises(_a ) as error_info: a = principal_component_analysis(_a, _a ) if not np.allclose(_a, _a ): raise AssertionError assert error_info.type is AssertionError if __name__ == "__main__": import doctest doctest.testmod()
361
# This script creates a super tiny model that is useful inside tests, when we just want to test that # the machinery works, without needing to the check the quality of the outcomes. # # This version creates a tiny vocab first, and then a tiny model - so the outcome is truly tiny - # all files ~60KB. As compared to taking a full-size model, reducing to the minimum its layers and # emb dimensions, but keeping the full vocab + merges files, leading to ~3MB in total for all files. # The latter is done by `fsmt-make-super-tiny-model.py`. # # It will be used then as "stas/tiny-wmt19-en-ru" from pathlib import Path import json import tempfile from transformers import FSMTTokenizer, FSMTConfig, FSMTForConditionalGeneration from transformers.models.fsmt.tokenization_fsmt import VOCAB_FILES_NAMES UpperCamelCase__ : Optional[Any] = """tiny-wmt19-en-ru""" # Build # borrowed from a test UpperCamelCase__ : Any = [ """l""", """o""", """w""", """e""", """r""", """s""", """t""", """i""", """d""", """n""", """w</w>""", """r</w>""", """t</w>""", """lo""", """low""", """er</w>""", """low</w>""", """lowest</w>""", """newer</w>""", """wider</w>""", """<unk>""", ] UpperCamelCase__ : List[Any] = dict(zip(vocab, range(len(vocab)))) UpperCamelCase__ : Any = ["""l o 123""", """lo w 1456""", """e r</w> 1789""", """"""] with tempfile.TemporaryDirectory() as tmpdirname: UpperCamelCase__ : Optional[Any] = Path(tmpdirname) UpperCamelCase__ : Tuple = build_dir / VOCAB_FILES_NAMES["""src_vocab_file"""] UpperCamelCase__ : int = build_dir / VOCAB_FILES_NAMES["""tgt_vocab_file"""] UpperCamelCase__ : Union[str, Any] = build_dir / VOCAB_FILES_NAMES["""merges_file"""] with open(src_vocab_file, """w""") as fp: fp.write(json.dumps(vocab_tokens)) with open(tgt_vocab_file, """w""") as fp: fp.write(json.dumps(vocab_tokens)) with open(merges_file, """w""") as fp: fp.write("""\n""".join(merges)) UpperCamelCase__ : Dict = FSMTTokenizer( langs=["""en""", """ru"""], src_vocab_size=len(vocab), tgt_vocab_size=len(vocab), src_vocab_file=src_vocab_file, tgt_vocab_file=tgt_vocab_file, merges_file=merges_file, ) UpperCamelCase__ : Union[str, Any] = FSMTConfig( langs=["""ru""", """en"""], src_vocab_size=1_000, tgt_vocab_size=1_000, d_model=4, encoder_layers=1, decoder_layers=1, encoder_ffn_dim=4, decoder_ffn_dim=4, encoder_attention_heads=1, decoder_attention_heads=1, ) UpperCamelCase__ : Union[str, Any] = FSMTForConditionalGeneration(config) print(F"num of params {tiny_model.num_parameters()}") # Test UpperCamelCase__ : List[str] = tokenizer(["""Making tiny model"""], return_tensors="""pt""") UpperCamelCase__ : Tuple = tiny_model(**batch) print("""test output:""", len(outputs.logits[0])) # Save tiny_model.half() # makes it smaller tiny_model.save_pretrained(mname_tiny) tokenizer.save_pretrained(mname_tiny) print(F"Generated {mname_tiny}") # Upload # transformers-cli upload tiny-wmt19-en-ru
330
0
import os import tempfile import unittest from pathlib import Path from transformers import AutoConfig, is_torch_available from transformers.testing_utils import require_torch, torch_device if is_torch_available(): from transformers import PyTorchBenchmark, PyTorchBenchmarkArguments @require_torch class lowerCamelCase_ ( unittest.TestCase ): def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : int ): '''simple docstring''' for model_result in results.values(): for batch_size, sequence_length in zip(model_result['''bs'''] ,model_result['''ss'''] ): a = model_result['''result'''][batch_size][sequence_length] self.assertIsNotNone(snake_case__ ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ): '''simple docstring''' a = '''sshleifer/tiny-gpt2''' a = PyTorchBenchmarkArguments( models=[MODEL_ID] ,training=snake_case__ ,inference=snake_case__ ,sequence_lengths=[8] ,batch_sizes=[1] ,multi_process=snake_case__ ,) a = PyTorchBenchmark(snake_case__ ) a = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' a = '''sgugger/tiny-distilbert-classification''' a = PyTorchBenchmarkArguments( models=[MODEL_ID] ,training=snake_case__ ,inference=snake_case__ ,sequence_lengths=[8] ,batch_sizes=[1] ,multi_process=snake_case__ ,only_pretrain_model=snake_case__ ,) a = PyTorchBenchmark(snake_case__ ) a = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' a = '''sshleifer/tiny-gpt2''' a = PyTorchBenchmarkArguments( models=[MODEL_ID] ,training=snake_case__ ,inference=snake_case__ ,torchscript=snake_case__ ,sequence_lengths=[8] ,batch_sizes=[1] ,multi_process=snake_case__ ,) a = PyTorchBenchmark(snake_case__ ) a = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) @unittest.skipIf(torch_device == '''cpu''' ,'''Cant do half precision''' ) def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' a = '''sshleifer/tiny-gpt2''' a = PyTorchBenchmarkArguments( models=[MODEL_ID] ,training=snake_case__ ,inference=snake_case__ ,fpaa=snake_case__ ,sequence_lengths=[8] ,batch_sizes=[1] ,multi_process=snake_case__ ,) a = PyTorchBenchmark(snake_case__ ) a = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ): '''simple docstring''' a = '''sshleifer/tiny-gpt2''' a = AutoConfig.from_pretrained(snake_case__ ) # set architectures equal to `None` a = None a = PyTorchBenchmarkArguments( models=[MODEL_ID] ,training=snake_case__ ,inference=snake_case__ ,sequence_lengths=[8] ,batch_sizes=[1] ,multi_process=snake_case__ ,) a = PyTorchBenchmark(snake_case__ ,configs=[config] ) a = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ): '''simple docstring''' a = '''sshleifer/tiny-gpt2''' a = PyTorchBenchmarkArguments( models=[MODEL_ID] ,training=snake_case__ ,inference=snake_case__ ,sequence_lengths=[8] ,batch_sizes=[1] ,multi_process=snake_case__ ,) a = PyTorchBenchmark(snake_case__ ) a = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) @unittest.skipIf(torch_device == '''cpu''' ,'''Can\'t do half precision''' ) def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ): '''simple docstring''' a = '''sshleifer/tiny-gpt2''' a = PyTorchBenchmarkArguments( models=[MODEL_ID] ,training=snake_case__ ,inference=snake_case__ ,sequence_lengths=[8] ,batch_sizes=[1] ,fpaa=snake_case__ ,multi_process=snake_case__ ,) a = PyTorchBenchmark(snake_case__ ) a = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ): '''simple docstring''' a = '''sshleifer/tiny-gpt2''' a = AutoConfig.from_pretrained(snake_case__ ) a = PyTorchBenchmarkArguments( models=[MODEL_ID] ,training=snake_case__ ,inference=snake_case__ ,sequence_lengths=[8] ,batch_sizes=[1] ,multi_process=snake_case__ ,) a = PyTorchBenchmark(snake_case__ ,configs=[config] ) a = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ): '''simple docstring''' a = '''sshleifer/tinier_bart''' a = AutoConfig.from_pretrained(snake_case__ ) a = PyTorchBenchmarkArguments( models=[MODEL_ID] ,training=snake_case__ ,inference=snake_case__ ,sequence_lengths=[8] ,batch_sizes=[1] ,multi_process=snake_case__ ,) a = PyTorchBenchmark(snake_case__ ,configs=[config] ) a = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' a = '''sshleifer/tiny-gpt2''' a = AutoConfig.from_pretrained(snake_case__ ) a = PyTorchBenchmarkArguments( models=[MODEL_ID] ,training=snake_case__ ,inference=snake_case__ ,sequence_lengths=[8] ,batch_sizes=[1] ,multi_process=snake_case__ ,) a = PyTorchBenchmark(snake_case__ ,configs=[config] ) a = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' a = '''sshleifer/tinier_bart''' a = AutoConfig.from_pretrained(snake_case__ ) a = PyTorchBenchmarkArguments( models=[MODEL_ID] ,training=snake_case__ ,inference=snake_case__ ,sequence_lengths=[8] ,batch_sizes=[1] ,multi_process=snake_case__ ,) a = PyTorchBenchmark(snake_case__ ,configs=[config] ) a = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ): '''simple docstring''' a = '''sshleifer/tiny-gpt2''' with tempfile.TemporaryDirectory() as tmp_dir: a = PyTorchBenchmarkArguments( models=[MODEL_ID] ,training=snake_case__ ,inference=snake_case__ ,save_to_csv=snake_case__ ,sequence_lengths=[8] ,batch_sizes=[1] ,inference_time_csv_file=os.path.join(snake_case__ ,'''inf_time.csv''' ) ,train_memory_csv_file=os.path.join(snake_case__ ,'''train_mem.csv''' ) ,inference_memory_csv_file=os.path.join(snake_case__ ,'''inf_mem.csv''' ) ,train_time_csv_file=os.path.join(snake_case__ ,'''train_time.csv''' ) ,env_info_csv_file=os.path.join(snake_case__ ,'''env.csv''' ) ,multi_process=snake_case__ ,) a = PyTorchBenchmark(snake_case__ ) benchmark.run() self.assertTrue(Path(os.path.join(snake_case__ ,'''inf_time.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(snake_case__ ,'''train_time.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(snake_case__ ,'''inf_mem.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(snake_case__ ,'''train_mem.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(snake_case__ ,'''env.csv''' ) ).exists() ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ): '''simple docstring''' a = '''sshleifer/tiny-gpt2''' def _check_summary_is_not_empty(__lowerCamelCase : List[Any] ): self.assertTrue(hasattr(snake_case__ ,'''sequential''' ) ) self.assertTrue(hasattr(snake_case__ ,'''cumulative''' ) ) self.assertTrue(hasattr(snake_case__ ,'''current''' ) ) self.assertTrue(hasattr(snake_case__ ,'''total''' ) ) with tempfile.TemporaryDirectory() as tmp_dir: a = PyTorchBenchmarkArguments( models=[MODEL_ID] ,training=snake_case__ ,inference=snake_case__ ,sequence_lengths=[8] ,batch_sizes=[1] ,log_filename=os.path.join(snake_case__ ,'''log.txt''' ) ,log_print=snake_case__ ,trace_memory_line_by_line=snake_case__ ,multi_process=snake_case__ ,) a = PyTorchBenchmark(snake_case__ ) a = benchmark.run() _check_summary_is_not_empty(result.inference_summary ) _check_summary_is_not_empty(result.train_summary ) self.assertTrue(Path(os.path.join(snake_case__ ,'''log.txt''' ) ).exists() )
362
import inspect import os import torch from transformers import AutoModel from transformers.testing_utils import mockenv_context from transformers.trainer_utils import set_seed import accelerate from accelerate.accelerator import Accelerator from accelerate.state import AcceleratorState from accelerate.test_utils.testing import ( AccelerateTestCase, TempDirTestCase, execute_subprocess_async, require_cuda, require_fsdp, require_multi_gpu, slow, ) from accelerate.utils.constants import ( FSDP_AUTO_WRAP_POLICY, FSDP_BACKWARD_PREFETCH, FSDP_SHARDING_STRATEGY, FSDP_STATE_DICT_TYPE, ) from accelerate.utils.dataclasses import FullyShardedDataParallelPlugin from accelerate.utils.other import patch_environment set_seed(42) UpperCamelCase__ : Optional[Any] = """bert-base-cased""" UpperCamelCase__ : int = """fp16""" UpperCamelCase__ : str = """bf16""" UpperCamelCase__ : List[Any] = [FPaa, BFaa] @require_fsdp @require_cuda class lowerCamelCase_ ( a_ ): def SCREAMING_SNAKE_CASE_ ( self : int ): '''simple docstring''' super().setUp() a = dict( ACCELERATE_USE_FSDP='''true''' ,MASTER_ADDR='''localhost''' ,MASTER_PORT='''10999''' ,RANK='''0''' ,LOCAL_RANK='''0''' ,WORLD_SIZE='''1''' ,) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import ShardingStrategy for i, strategy in enumerate(__lowerCamelCase ): a = self.dist_env.copy() a = F"""{i + 1}""" a = strategy with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() self.assertEqual(fsdp_plugin.sharding_strategy ,ShardingStrategy(i + 1 ) ) def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import BackwardPrefetch for i, prefetch_policy in enumerate(__lowerCamelCase ): a = self.dist_env.copy() a = prefetch_policy with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() if prefetch_policy == "NO_PREFETCH": self.assertIsNone(fsdp_plugin.backward_prefetch ) else: self.assertEqual(fsdp_plugin.backward_prefetch ,BackwardPrefetch(i + 1 ) ) def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType for i, state_dict_type in enumerate(__lowerCamelCase ): a = self.dist_env.copy() a = state_dict_type with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() self.assertEqual(fsdp_plugin.state_dict_type ,StateDictType(i + 1 ) ) if state_dict_type == "FULL_STATE_DICT": self.assertTrue(fsdp_plugin.state_dict_config.offload_to_cpu ) self.assertTrue(fsdp_plugin.state_dict_config.ranka_only ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ): '''simple docstring''' a = AutoModel.from_pretrained(__lowerCamelCase ) for policy in FSDP_AUTO_WRAP_POLICY: a = self.dist_env.copy() a = policy if policy == "TRANSFORMER_BASED_WRAP": a = '''BertLayer''' elif policy == "SIZE_BASED_WRAP": a = '''2000''' with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() fsdp_plugin.set_auto_wrap_policy(__lowerCamelCase ) if policy == "NO_WRAP": self.assertIsNone(fsdp_plugin.auto_wrap_policy ) else: self.assertIsNotNone(fsdp_plugin.auto_wrap_policy ) a = self.dist_env.copy() a = '''TRANSFORMER_BASED_WRAP''' a = '''T5Layer''' with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() with self.assertRaises(__lowerCamelCase ) as cm: fsdp_plugin.set_auto_wrap_policy(__lowerCamelCase ) self.assertTrue('''Could not find the transformer layer class to wrap in the model.''' in str(cm.exception ) ) a = self.dist_env.copy() a = '''SIZE_BASED_WRAP''' a = '''0''' with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() fsdp_plugin.set_auto_wrap_policy(__lowerCamelCase ) self.assertIsNone(fsdp_plugin.auto_wrap_policy ) def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import MixedPrecision from torch.distributed.fsdp.sharded_grad_scaler import ShardedGradScaler for mp_dtype in dtypes: a = self.dist_env.copy() a = mp_dtype with mockenv_context(**__lowerCamelCase ): a = Accelerator() if mp_dtype == "fp16": a = torch.floataa elif mp_dtype == "bf16": a = torch.bfloataa a = MixedPrecision(param_dtype=__lowerCamelCase ,reduce_dtype=__lowerCamelCase ,buffer_dtype=__lowerCamelCase ) self.assertEqual(accelerator.state.fsdp_plugin.mixed_precision_policy ,__lowerCamelCase ) if mp_dtype == FPaa: self.assertTrue(isinstance(accelerator.scaler ,__lowerCamelCase ) ) elif mp_dtype == BFaa: self.assertIsNone(accelerator.scaler ) AcceleratorState._reset_state(__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import CPUOffload for flag in [True, False]: a = self.dist_env.copy() a = str(__lowerCamelCase ).lower() with mockenv_context(**__lowerCamelCase ): a = FullyShardedDataParallelPlugin() self.assertEqual(fsdp_plugin.cpu_offload ,CPUOffload(offload_params=__lowerCamelCase ) ) @require_fsdp @require_multi_gpu @slow class lowerCamelCase_ ( a_ ): def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' super().setUp() a = 0.82 a = [ '''fsdp_shard_grad_op_transformer_based_wrap''', '''fsdp_full_shard_transformer_based_wrap''', ] a = { '''multi_gpu_fp16''': 32_00, '''fsdp_shard_grad_op_transformer_based_wrap_fp16''': 20_00, '''fsdp_full_shard_transformer_based_wrap_fp16''': 19_00, # Disabling below test as it overwhelms the RAM memory usage # on CI self-hosted runner leading to tests getting killed. # "fsdp_full_shard_cpu_offload_transformer_based_wrap_fp32": 1500, # fp16 was leading to indefinite hang } a = 1_60 a = 1_60 a = inspect.getfile(accelerate.test_utils ) a = os.path.sep.join(mod_file.split(os.path.sep )[:-1] + ['''scripts''', '''external_deps'''] ) def SCREAMING_SNAKE_CASE_ ( self : List[str] ): '''simple docstring''' a = os.path.join(self.test_scripts_folder ,'''test_performance.py''' ) a = ['''accelerate''', '''launch''', '''--num_processes=2''', '''--num_machines=1''', '''--machine_rank=0''', '''--use_fsdp'''] for config in self.performance_configs: a = cmd.copy() for i, strategy in enumerate(__lowerCamelCase ): if strategy.lower() in config: cmd_config.append(F"""--fsdp_sharding_strategy={i+1}""" ) break if "fp32" in config: cmd_config.append('''--mixed_precision=no''' ) else: cmd_config.append('''--mixed_precision=fp16''' ) if "cpu_offload" in config: cmd_config.append('''--fsdp_offload_params=True''' ) for policy in FSDP_AUTO_WRAP_POLICY: if policy.lower() in config: cmd_config.append(F"""--fsdp_auto_wrap_policy={policy}""" ) break if policy == "TRANSFORMER_BASED_WRAP": cmd_config.append('''--fsdp_transformer_layer_cls_to_wrap=BertLayer''' ) elif policy == "SIZE_BASED_WRAP": cmd_config.append('''--fsdp_min_num_params=2000''' ) cmd_config.extend( [ self.test_file_path, F"""--output_dir={self.tmpdir}""", F"""--performance_lower_bound={self.performance_lower_bound}""", ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(__lowerCamelCase ,env=os.environ.copy() ) def SCREAMING_SNAKE_CASE_ ( self : Any ): '''simple docstring''' a = os.path.join(self.test_scripts_folder ,'''test_checkpointing.py''' ) a = [ '''accelerate''', '''launch''', '''--num_processes=2''', '''--num_machines=1''', '''--machine_rank=0''', '''--use_fsdp''', '''--mixed_precision=fp16''', '''--fsdp_transformer_layer_cls_to_wrap=BertLayer''', ] for i, strategy in enumerate(__lowerCamelCase ): a = cmd.copy() cmd_config.append(F"""--fsdp_sharding_strategy={i+1}""" ) if strategy != "FULL_SHARD": continue a = len(__lowerCamelCase ) for state_dict_type in FSDP_STATE_DICT_TYPE: a = cmd_config[:state_dict_config_index] cmd_config.append(F"""--fsdp_state_dict_type={state_dict_type}""" ) cmd_config.extend( [ self.test_file_path, F"""--output_dir={self.tmpdir}""", '''--partial_train_epoch=1''', ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(__lowerCamelCase ,env=os.environ.copy() ) a = cmd_config[:-1] a = os.path.join(self.tmpdir ,'''epoch_0''' ) cmd_config.extend( [ F"""--resume_from_checkpoint={resume_from_checkpoint}""", ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(__lowerCamelCase ,env=os.environ.copy() ) def SCREAMING_SNAKE_CASE_ ( self : int ): '''simple docstring''' a = os.path.join(self.test_scripts_folder ,'''test_peak_memory_usage.py''' ) a = [ '''accelerate''', '''launch''', '''--num_processes=2''', '''--num_machines=1''', '''--machine_rank=0''', ] for spec, peak_mem_upper_bound in self.peak_memory_usage_upper_bound.items(): a = cmd.copy() if "fp16" in spec: cmd_config.extend(['''--mixed_precision=fp16'''] ) else: cmd_config.extend(['''--mixed_precision=no'''] ) if "multi_gpu" in spec: continue else: cmd_config.extend(['''--use_fsdp'''] ) for i, strategy in enumerate(__lowerCamelCase ): if strategy.lower() in spec: cmd_config.append(F"""--fsdp_sharding_strategy={i+1}""" ) break if "cpu_offload" in spec: cmd_config.append('''--fsdp_offload_params=True''' ) for policy in FSDP_AUTO_WRAP_POLICY: if policy.lower() in spec: cmd_config.append(F"""--fsdp_auto_wrap_policy={policy}""" ) break if policy == "TRANSFORMER_BASED_WRAP": cmd_config.append('''--fsdp_transformer_layer_cls_to_wrap=BertLayer''' ) elif policy == "SIZE_BASED_WRAP": cmd_config.append('''--fsdp_min_num_params=2000''' ) cmd_config.extend( [ self.test_file_path, F"""--output_dir={self.tmpdir}""", F"""--peak_memory_upper_bound={peak_mem_upper_bound}""", F"""--n_train={self.n_train}""", F"""--n_val={self.n_val}""", ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(__lowerCamelCase ,env=os.environ.copy() )
330
0
"""simple docstring""" from __future__ import annotations def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ = None, snake_case_ = None ) -> None: """simple docstring""" if start is None: a = 0 if end is None: a = len(_lowercase ) - 1 if start >= end: return a = (start + end) // 2 slowsort(_lowercase, _lowercase, _lowercase ) slowsort(_lowercase, mid + 1, _lowercase ) if sequence[end] < sequence[mid]: a = sequence[mid], sequence[end] slowsort(_lowercase, _lowercase, end - 1 ) if __name__ == "__main__": from doctest import testmod testmod()
363
from __future__ import annotations import os from collections.abc import Mapping UpperCamelCase__ : Any = tuple[int, int] class lowerCamelCase_ : def __init__( self : Optional[Any] ,__lowerCamelCase : set[int] ,__lowerCamelCase : Mapping[EdgeT, int] ): '''simple docstring''' a = vertices a = { (min(__lowerCamelCase ), max(__lowerCamelCase )): weight for edge, weight in edges.items() } def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : EdgeT ,__lowerCamelCase : int ): '''simple docstring''' self.vertices.add(edge[0] ) self.vertices.add(edge[1] ) a = weight def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' a = Graph({min(self.vertices )} ,{} ) a = 42 a = 42 a = 42 a = 42 while len(subgraph.vertices ) < len(self.vertices ): a = max(self.edges.values() ) + 1 for edge, weight in self.edges.items(): if (edge[0] in subgraph.vertices) ^ (edge[1] in subgraph.vertices): if weight < min_weight: a = edge a = weight subgraph.add_edge(__lowerCamelCase ,__lowerCamelCase ) return subgraph def SCREAMING_SNAKE_CASE__ ( snake_case_ = "p107_network.txt" ) -> int: """simple docstring""" a = os.path.abspath(os.path.dirname(snake_case_ ) ) a = os.path.join(snake_case_, snake_case_ ) a = {} a = 42 a = 42 a = 42 with open(snake_case_ ) as f: a = f.read().strip().split('''\n''' ) a = [line.split(''',''' ) for line in data] for edgea in range(1, len(snake_case_ ) ): for edgea in range(snake_case_ ): if adjaceny_matrix[edgea][edgea] != "-": a = int(adjaceny_matrix[edgea][edgea] ) a = Graph(set(range(len(snake_case_ ) ) ), snake_case_ ) a = graph.prims_algorithm() a = sum(graph.edges.values() ) a = sum(subgraph.edges.values() ) return initial_total - optimal_total if __name__ == "__main__": print(F"{solution() = }")
330
0
import warnings from typing import List, Optional, Tuple, Union import numpy as np import PIL import torch from ...models import UNetaDModel from ...schedulers import RePaintScheduler from ...utils import PIL_INTERPOLATION, logging, randn_tensor from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput UpperCamelCase__ : Dict = logging.get_logger(__name__) # pylint: disable=invalid-name def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> List[Any]: """simple docstring""" warnings.warn( '''The preprocess method is deprecated and will be removed in a future version. Please''' ''' use VaeImageProcessor.preprocess instead''', snake_case_, ) if isinstance(snake_case_, torch.Tensor ): return image elif isinstance(snake_case_, PIL.Image.Image ): a = [image] if isinstance(image[0], PIL.Image.Image ): a , a = image[0].size a , a = (x - x % 8 for x in (w, h)) # resize to integer multiple of 8 a = [np.array(i.resize((w, h), resample=PIL_INTERPOLATION['''lanczos'''] ) )[None, :] for i in image] a = np.concatenate(snake_case_, axis=0 ) a = np.array(snake_case_ ).astype(np.floataa ) / 2_5_5.0 a = image.transpose(0, 3, 1, 2 ) a = 2.0 * image - 1.0 a = torch.from_numpy(snake_case_ ) elif isinstance(image[0], torch.Tensor ): a = torch.cat(snake_case_, dim=0 ) return image def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> List[Any]: """simple docstring""" if isinstance(snake_case_, torch.Tensor ): return mask elif isinstance(snake_case_, PIL.Image.Image ): a = [mask] if isinstance(mask[0], PIL.Image.Image ): a , a = mask[0].size a , a = (x - x % 3_2 for x in (w, h)) # resize to integer multiple of 32 a = [np.array(m.convert('''L''' ).resize((w, h), resample=PIL_INTERPOLATION['''nearest'''] ) )[None, :] for m in mask] a = np.concatenate(snake_case_, axis=0 ) a = mask.astype(np.floataa ) / 2_5_5.0 a = 0 a = 1 a = torch.from_numpy(snake_case_ ) elif isinstance(mask[0], torch.Tensor ): a = torch.cat(snake_case_, dim=0 ) return mask class lowerCamelCase_ ( lowerCAmelCase__ ): SCREAMING_SNAKE_CASE_ = 42 SCREAMING_SNAKE_CASE_ = 42 def __init__( self : List[str] ,__lowerCamelCase : Any ,__lowerCamelCase : int ): '''simple docstring''' super().__init__() self.register_modules(unet=a__ ,scheduler=a__ ) @torch.no_grad() def __call__( self : Tuple ,__lowerCamelCase : Optional[int] ,__lowerCamelCase : List[Any] ,__lowerCamelCase : Any = 2_50 ,__lowerCamelCase : Union[str, Any] = 0.0 ,__lowerCamelCase : Union[str, Any] = 10 ,__lowerCamelCase : Optional[int] = 10 ,__lowerCamelCase : Optional[Any] = None ,__lowerCamelCase : int = "pil" ,__lowerCamelCase : List[Any] = True ,): '''simple docstring''' a = image a = _preprocess_image(a__ ) a = original_image.to(device=self.device ,dtype=self.unet.dtype ) a = _preprocess_mask(a__ ) a = mask_image.to(device=self.device ,dtype=self.unet.dtype ) a = original_image.shape[0] # sample gaussian noise to begin the loop if isinstance(a__ ,a__ ) and len(a__ ) != batch_size: raise ValueError( F"""You have passed a list of generators of length {len(a__ )}, but requested an effective batch""" F""" size of {batch_size}. Make sure the batch size matches the length of the generators.""" ) a = original_image.shape a = randn_tensor(a__ ,generator=a__ ,device=self.device ,dtype=self.unet.dtype ) # set step values self.scheduler.set_timesteps(a__ ,a__ ,a__ ,self.device ) a = eta a = self.scheduler.timesteps[0] + 1 a = generator[0] if isinstance(a__ ,a__ ) else generator for i, t in enumerate(self.progress_bar(self.scheduler.timesteps ) ): if t < t_last: # predict the noise residual a = self.unet(a__ ,a__ ).sample # compute previous image: x_t -> x_t-1 a = self.scheduler.step(a__ ,a__ ,a__ ,a__ ,a__ ,a__ ).prev_sample else: # compute the reverse: x_t-1 -> x_t a = self.scheduler.undo_step(a__ ,a__ ,a__ ) a = t a = (image / 2 + 0.5).clamp(0 ,1 ) a = image.cpu().permute(0 ,2 ,3 ,1 ).numpy() if output_type == "pil": a = self.numpy_to_pil(a__ ) if not return_dict: return (image,) return ImagePipelineOutput(images=a__ )
364
from typing import Optional, Tuple, Union import tensorflow as tf from ...activations_tf import ACTaFN from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward from ...modeling_tf_outputs import ( TFBaseModelOutputWithNoAttention, TFBaseModelOutputWithPoolingAndNoAttention, TFSequenceClassifierOutput, ) from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs from ...tf_utils import shape_list from ...utils import logging from .configuration_regnet import RegNetConfig UpperCamelCase__ : List[Any] = logging.get_logger(__name__) # General docstring UpperCamelCase__ : List[Any] = """RegNetConfig""" # Base docstring UpperCamelCase__ : Dict = """facebook/regnet-y-040""" UpperCamelCase__ : int = [1, 1_088, 7, 7] # Image classification docstring UpperCamelCase__ : Optional[Any] = """facebook/regnet-y-040""" UpperCamelCase__ : Dict = """tabby, tabby cat""" UpperCamelCase__ : Dict = [ """facebook/regnet-y-040""", # See all regnet models at https://huggingface.co/models?filter=regnet ] class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : List[str] ,__lowerCamelCase : int ,__lowerCamelCase : int = 3 ,__lowerCamelCase : int = 1 ,__lowerCamelCase : int = 1 ,__lowerCamelCase : Optional[str] = "relu" ,**__lowerCamelCase : str ,): '''simple docstring''' super().__init__(**__lowerCamelCase ) # The padding and conv has been verified in # https://colab.research.google.com/gist/sayakpaul/854bc10eeaf21c9ee2119e0b9f3841a7/scratchpad.ipynb a = tf.keras.layers.ZeroPaddingaD(padding=kernel_size // 2 ) a = tf.keras.layers.ConvaD( filters=__lowerCamelCase ,kernel_size=__lowerCamelCase ,strides=__lowerCamelCase ,padding='''VALID''' ,groups=__lowerCamelCase ,use_bias=__lowerCamelCase ,name='''convolution''' ,) a = tf.keras.layers.BatchNormalization(epsilon=1e-5 ,momentum=0.9 ,name='''normalization''' ) a = ACTaFN[activation] if activation is not None else tf.identity def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : List[str] ): '''simple docstring''' a = self.convolution(self.padding(__lowerCamelCase ) ) a = self.normalization(__lowerCamelCase ) a = self.activation(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Any ,__lowerCamelCase : RegNetConfig ,**__lowerCamelCase : List[Any] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = config.num_channels a = TFRegNetConvLayer( out_channels=config.embedding_size ,kernel_size=3 ,stride=2 ,activation=config.hidden_act ,name='''embedder''' ,) def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : Optional[Any] ): '''simple docstring''' a = shape_list(__lowerCamelCase )[1] if tf.executing_eagerly() and 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.''' ) # When running on CPU, `tf.keras.layers.Conv2D` doesn't support `NCHW` format. # So change the input format from `NCHW` to `NHWC`. # shape = (batch_size, in_height, in_width, in_channels=num_channels) a = tf.transpose(__lowerCamelCase ,perm=(0, 2, 3, 1) ) a = self.embedder(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : str ,__lowerCamelCase : int ,__lowerCamelCase : int = 2 ,**__lowerCamelCase : Tuple ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = tf.keras.layers.ConvaD( filters=__lowerCamelCase ,kernel_size=1 ,strides=__lowerCamelCase ,use_bias=__lowerCamelCase ,name='''convolution''' ) a = tf.keras.layers.BatchNormalization(epsilon=1e-5 ,momentum=0.9 ,name='''normalization''' ) def SCREAMING_SNAKE_CASE_ ( self : Dict ,__lowerCamelCase : tf.Tensor ,__lowerCamelCase : bool = False ): '''simple docstring''' return self.normalization(self.convolution(__lowerCamelCase ) ,training=__lowerCamelCase ) class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : List[Any] ,__lowerCamelCase : int ,__lowerCamelCase : int ,**__lowerCamelCase : str ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = tf.keras.layers.GlobalAveragePoolingaD(keepdims=__lowerCamelCase ,name='''pooler''' ) a = [ tf.keras.layers.ConvaD(filters=__lowerCamelCase ,kernel_size=1 ,activation='''relu''' ,name='''attention.0''' ), tf.keras.layers.ConvaD(filters=__lowerCamelCase ,kernel_size=1 ,activation='''sigmoid''' ,name='''attention.2''' ), ] def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : Optional[Any] ): '''simple docstring''' a = self.pooler(__lowerCamelCase ) for layer_module in self.attention: a = layer_module(__lowerCamelCase ) a = hidden_state * pooled return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Union[str, Any] ,__lowerCamelCase : RegNetConfig ,__lowerCamelCase : int ,__lowerCamelCase : int ,__lowerCamelCase : int = 1 ,**__lowerCamelCase : Dict ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = in_channels != out_channels or stride != 1 a = max(1 ,out_channels // config.groups_width ) a = ( TFRegNetShortCut(__lowerCamelCase ,stride=__lowerCamelCase ,name='''shortcut''' ) if should_apply_shortcut else tf.keras.layers.Activation('''linear''' ,name='''shortcut''' ) ) # `self.layers` instead of `self.layer` because that is a reserved argument. a = [ TFRegNetConvLayer(__lowerCamelCase ,kernel_size=1 ,activation=config.hidden_act ,name='''layer.0''' ), TFRegNetConvLayer( __lowerCamelCase ,stride=__lowerCamelCase ,groups=__lowerCamelCase ,activation=config.hidden_act ,name='''layer.1''' ), TFRegNetConvLayer(__lowerCamelCase ,kernel_size=1 ,activation=__lowerCamelCase ,name='''layer.2''' ), ] a = ACTaFN[config.hidden_act] def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = hidden_state for layer_module in self.layers: a = layer_module(__lowerCamelCase ) a = self.shortcut(__lowerCamelCase ) hidden_state += residual a = self.activation(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Dict ,__lowerCamelCase : RegNetConfig ,__lowerCamelCase : int ,__lowerCamelCase : int ,__lowerCamelCase : int = 1 ,**__lowerCamelCase : List[str] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = in_channels != out_channels or stride != 1 a = max(1 ,out_channels // config.groups_width ) a = ( TFRegNetShortCut(__lowerCamelCase ,stride=__lowerCamelCase ,name='''shortcut''' ) if should_apply_shortcut else tf.keras.layers.Activation('''linear''' ,name='''shortcut''' ) ) a = [ TFRegNetConvLayer(__lowerCamelCase ,kernel_size=1 ,activation=config.hidden_act ,name='''layer.0''' ), TFRegNetConvLayer( __lowerCamelCase ,stride=__lowerCamelCase ,groups=__lowerCamelCase ,activation=config.hidden_act ,name='''layer.1''' ), TFRegNetSELayer(__lowerCamelCase ,reduced_channels=int(round(in_channels / 4 ) ) ,name='''layer.2''' ), TFRegNetConvLayer(__lowerCamelCase ,kernel_size=1 ,activation=__lowerCamelCase ,name='''layer.3''' ), ] a = ACTaFN[config.hidden_act] def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ,__lowerCamelCase : str ): '''simple docstring''' a = hidden_state for layer_module in self.layers: a = layer_module(__lowerCamelCase ) a = self.shortcut(__lowerCamelCase ) hidden_state += residual a = self.activation(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Optional[int] ,__lowerCamelCase : RegNetConfig ,__lowerCamelCase : int ,__lowerCamelCase : int ,__lowerCamelCase : int = 2 ,__lowerCamelCase : int = 2 ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = TFRegNetXLayer if config.layer_type == '''x''' else TFRegNetYLayer a = [ # downsampling is done in the first layer with stride of 2 layer(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ,stride=__lowerCamelCase ,name='''layers.0''' ), *[layer(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ,name=F"""layers.{i+1}""" ) for i in range(depth - 1 )], ] def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : int ): '''simple docstring''' for layer_module in self.layers: a = layer_module(__lowerCamelCase ) return hidden_state class lowerCamelCase_ ( tf.keras.layers.Layer ): def __init__( self : Union[str, Any] ,__lowerCamelCase : RegNetConfig ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = [] # based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input self.stages.append( TFRegNetStage( __lowerCamelCase ,config.embedding_size ,config.hidden_sizes[0] ,stride=2 if config.downsample_in_first_stage else 1 ,depth=config.depths[0] ,name='''stages.0''' ,) ) a = zip(config.hidden_sizes ,config.hidden_sizes[1:] ) for i, ((in_channels, out_channels), depth) in enumerate(zip(__lowerCamelCase ,config.depths[1:] ) ): self.stages.append(TFRegNetStage(__lowerCamelCase ,__lowerCamelCase ,__lowerCamelCase ,depth=__lowerCamelCase ,name=F"""stages.{i+1}""" ) ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : tf.Tensor ,__lowerCamelCase : bool = False ,__lowerCamelCase : bool = True ): '''simple docstring''' 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(__lowerCamelCase ) 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 TFBaseModelOutputWithNoAttention(last_hidden_state=__lowerCamelCase ,hidden_states=__lowerCamelCase ) @keras_serializable class lowerCamelCase_ ( tf.keras.layers.Layer ): SCREAMING_SNAKE_CASE_ = RegNetConfig def __init__( self : Dict ,__lowerCamelCase : Optional[int] ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = config a = TFRegNetEmbeddings(__lowerCamelCase ,name='''embedder''' ) a = TFRegNetEncoder(__lowerCamelCase ,name='''encoder''' ) a = tf.keras.layers.GlobalAveragePoolingaD(keepdims=__lowerCamelCase ,name='''pooler''' ) @unpack_inputs def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : tf.Tensor ,__lowerCamelCase : Optional[bool] = None ,__lowerCamelCase : Optional[bool] = None ,__lowerCamelCase : bool = False ,): '''simple docstring''' a = ( output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states ) a = return_dict if return_dict is not None else self.config.use_return_dict a = self.embedder(__lowerCamelCase ,training=__lowerCamelCase ) a = self.encoder( __lowerCamelCase ,output_hidden_states=__lowerCamelCase ,return_dict=__lowerCamelCase ,training=__lowerCamelCase ) a = encoder_outputs[0] a = self.pooler(__lowerCamelCase ) # Change to NCHW output format have uniformity in the modules a = tf.transpose(__lowerCamelCase ,perm=(0, 3, 1, 2) ) a = tf.transpose(__lowerCamelCase ,perm=(0, 3, 1, 2) ) # Change the other hidden state outputs to NCHW as well if output_hidden_states: a = tuple([tf.transpose(__lowerCamelCase ,perm=(0, 3, 1, 2) ) for h in encoder_outputs[1]] ) if not return_dict: return (last_hidden_state, pooled_output) + encoder_outputs[1:] return TFBaseModelOutputWithPoolingAndNoAttention( last_hidden_state=__lowerCamelCase ,pooler_output=__lowerCamelCase ,hidden_states=hidden_states if output_hidden_states else encoder_outputs.hidden_states ,) class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = RegNetConfig SCREAMING_SNAKE_CASE_ = 'regnet' SCREAMING_SNAKE_CASE_ = 'pixel_values' @property def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 2_24, 2_24) ,dtype=tf.floataa )} UpperCamelCase__ : Union[str, Any] = R""" Parameters: This model is a Tensorflow [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a regular Tensorflow Module and refer to the Tensorflow documentation for all matter related to general usage and behavior. config ([`RegNetConfig`]): 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 [`~TFPreTrainedModel.from_pretrained`] method to load the model weights. """ UpperCamelCase__ : List[str] = R""" Args: pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`): Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See [`ConveNextImageProcessor.__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 RegNet model outputting raw features without any specific head on top.' , a_ , ) class lowerCamelCase_ ( a_ ): def __init__( self : Optional[int] ,__lowerCamelCase : RegNetConfig ,*__lowerCamelCase : int ,**__lowerCamelCase : Union[str, Any] ): '''simple docstring''' super().__init__(__lowerCamelCase ,*__lowerCamelCase ,**__lowerCamelCase ) a = TFRegNetMainLayer(__lowerCamelCase ,name='''regnet''' ) @unpack_inputs @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 SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : tf.Tensor ,__lowerCamelCase : Optional[bool] = None ,__lowerCamelCase : Optional[bool] = None ,__lowerCamelCase : List[str]=False ,): '''simple docstring''' a = ( output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states ) a = return_dict if return_dict is not None else self.config.use_return_dict a = self.regnet( pixel_values=__lowerCamelCase ,output_hidden_states=__lowerCamelCase ,return_dict=__lowerCamelCase ,training=__lowerCamelCase ,) if not return_dict: return (outputs[0],) + outputs[1:] return TFBaseModelOutputWithPoolingAndNoAttention( last_hidden_state=outputs.last_hidden_state ,pooler_output=outputs.pooler_output ,hidden_states=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 ' , a_ , ) class lowerCamelCase_ ( a_ , a_ ): def __init__( self : Optional[int] ,__lowerCamelCase : RegNetConfig ,*__lowerCamelCase : str ,**__lowerCamelCase : Any ): '''simple docstring''' super().__init__(__lowerCamelCase ,*__lowerCamelCase ,**__lowerCamelCase ) a = config.num_labels a = TFRegNetMainLayer(__lowerCamelCase ,name='''regnet''' ) # classification head a = [ tf.keras.layers.Flatten(), tf.keras.layers.Dense(config.num_labels ,name='''classifier.1''' ) if config.num_labels > 0 else tf.identity, ] @unpack_inputs @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 SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : tf.Tensor = None ,__lowerCamelCase : tf.Tensor = None ,__lowerCamelCase : bool = None ,__lowerCamelCase : bool = None ,__lowerCamelCase : Dict=False ,): '''simple docstring''' a = ( output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states ) a = return_dict if return_dict is not None else self.config.use_return_dict a = self.regnet( __lowerCamelCase ,output_hidden_states=__lowerCamelCase ,return_dict=__lowerCamelCase ,training=__lowerCamelCase ) a = outputs.pooler_output if return_dict else outputs[1] a = self.classifier[0](__lowerCamelCase ) a = self.classifier[1](__lowerCamelCase ) a = None if labels is None else self.hf_compute_loss(labels=__lowerCamelCase ,logits=__lowerCamelCase ) if not return_dict: a = (logits,) + outputs[2:] return ((loss,) + output) if loss is not None else output return TFSequenceClassifierOutput(loss=__lowerCamelCase ,logits=__lowerCamelCase ,hidden_states=outputs.hidden_states )
330
0
def SCREAMING_SNAKE_CASE__ ( ) -> Any: """simple docstring""" for n in range(1, 1_0_0_0_0_0_0 ): yield n * (n + 1) // 2 def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Optional[Any]: """simple docstring""" a = 1 a = 2 while i * i <= n: a = 0 while n % i == 0: n //= i multiplicity += 1 divisors_count *= multiplicity + 1 i += 1 if n > 1: divisors_count *= 2 return divisors_count def SCREAMING_SNAKE_CASE__ ( ) -> Optional[Any]: """simple docstring""" return next(i for i in triangle_number_generator() if count_divisors(snake_case__ ) > 5_0_0 ) if __name__ == "__main__": print(solution())
365
from typing import List from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCamelCase__ : Union[str, Any] = logging.get_logger(__name__) UpperCamelCase__ : List[str] = { """snap-research/efficientformer-l1-300""": ( """https://huggingface.co/snap-research/efficientformer-l1-300/resolve/main/config.json""" ), } class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = 'efficientformer' def __init__( self : Optional[int] ,__lowerCamelCase : List[int] = [3, 2, 6, 4] ,__lowerCamelCase : List[int] = [48, 96, 2_24, 4_48] ,__lowerCamelCase : List[bool] = [True, True, True, True] ,__lowerCamelCase : int = 4_48 ,__lowerCamelCase : int = 32 ,__lowerCamelCase : int = 4 ,__lowerCamelCase : int = 7 ,__lowerCamelCase : int = 5 ,__lowerCamelCase : int = 8 ,__lowerCamelCase : int = 4 ,__lowerCamelCase : float = 0.0 ,__lowerCamelCase : int = 16 ,__lowerCamelCase : int = 3 ,__lowerCamelCase : int = 3 ,__lowerCamelCase : int = 3 ,__lowerCamelCase : int = 2 ,__lowerCamelCase : int = 1 ,__lowerCamelCase : float = 0.0 ,__lowerCamelCase : int = 1 ,__lowerCamelCase : bool = True ,__lowerCamelCase : bool = True ,__lowerCamelCase : float = 1e-5 ,__lowerCamelCase : str = "gelu" ,__lowerCamelCase : float = 0.02 ,__lowerCamelCase : float = 1e-12 ,__lowerCamelCase : int = 2_24 ,__lowerCamelCase : float = 1e-05 ,**__lowerCamelCase : Dict ,): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = hidden_act a = hidden_dropout_prob a = hidden_sizes a = num_hidden_layers a = num_attention_heads a = initializer_range a = layer_norm_eps a = patch_size a = num_channels a = depths a = mlp_expansion_ratio a = downsamples a = dim a = key_dim a = attention_ratio a = resolution a = pool_size a = downsample_patch_size a = downsample_stride a = downsample_pad a = drop_path_rate a = num_metaad_blocks a = distillation a = use_layer_scale a = layer_scale_init_value a = image_size a = batch_norm_eps
330
0
import math def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> List[str]: """simple docstring""" if initial_intensity < 0: raise ValueError('''The value of intensity cannot be negative''' ) # handling of negative values of initial intensity if angle < 0 or angle > 3_6_0: raise ValueError('''In Malus Law, the angle is in the range 0-360 degrees''' ) # handling of values out of allowed range return initial_intensity * (math.cos(math.radians(lowerCAmelCase__ ) ) ** 2) if __name__ == "__main__": import doctest doctest.testmod(name="""malus_law""")
366
import argparse from typing import Dict import tensorflow as tf import torch from tqdm import tqdm from transformers import BigBirdPegasusConfig, BigBirdPegasusForConditionalGeneration UpperCamelCase__ : Any = [ # tf -> hf ("""/""", """."""), ("""layer_""", """layers."""), ("""kernel""", """weight"""), ("""beta""", """bias"""), ("""gamma""", """weight"""), ("""pegasus""", """model"""), ] UpperCamelCase__ : Optional[Any] = [ (""".output.dense""", """.fc2"""), ("""intermediate.LayerNorm""", """final_layer_norm"""), ("""intermediate.dense""", """fc1"""), ] UpperCamelCase__ : Optional[Any] = ( INIT_COMMON + [ ("""attention.self.LayerNorm""", """self_attn_layer_norm"""), ("""attention.output.dense""", """self_attn.out_proj"""), ("""attention.self""", """self_attn"""), ("""attention.encdec.LayerNorm""", """encoder_attn_layer_norm"""), ("""attention.encdec_output.dense""", """encoder_attn.out_proj"""), ("""attention.encdec""", """encoder_attn"""), ("""key""", """k_proj"""), ("""value""", """v_proj"""), ("""query""", """q_proj"""), ("""decoder.LayerNorm""", """decoder.layernorm_embedding"""), ] + END_COMMON ) UpperCamelCase__ : List[str] = ( INIT_COMMON + [ ("""embeddings.word_embeddings""", """shared.weight"""), ("""embeddings.position_embeddings""", """embed_positions.weight"""), ("""attention.self.LayerNorm""", """self_attn_layer_norm"""), ("""attention.output.dense""", """self_attn.output"""), ("""attention.self""", """self_attn.self"""), ("""encoder.LayerNorm""", """encoder.layernorm_embedding"""), ] + END_COMMON ) UpperCamelCase__ : Optional[int] = [ """encdec/key/bias""", """encdec/query/bias""", """encdec/value/bias""", """self/key/bias""", """self/query/bias""", """self/value/bias""", """encdec_output/dense/bias""", """attention/output/dense/bias""", ] def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> List[Any]: """simple docstring""" for tf_name, hf_name in patterns: a = k.replace(snake_case_, snake_case_ ) return k def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> BigBirdPegasusForConditionalGeneration: """simple docstring""" a = BigBirdPegasusConfig(**snake_case_ ) a = BigBirdPegasusForConditionalGeneration(snake_case_ ) a = torch_model.state_dict() a = {} # separating decoder weights a = {k: tf_weights[k] for k in tf_weights if k.startswith('''pegasus/decoder''' )} a = {k: tf_weights[k] for k in tf_weights if not k.startswith('''pegasus/decoder''' )} for k, v in tqdm(decoder_weights.items(), '''tf -> hf conversion''' ): a = [k.endswith(snake_case_ ) for ending in KEYS_TO_IGNORE] if any(snake_case_ ): continue a = DECODER_PATTERNS a = rename_state_dict_key(snake_case_, snake_case_ ) if new_k not in state_dict: raise ValueError(f"""could not find new key {new_k} in state dict. (converted from {k})""" ) if any(True if i in k else False for i in ['''dense''', '''query''', '''key''', '''value'''] ): a = v.T a = torch.from_numpy(snake_case_ ) assert v.shape == state_dict[new_k].shape, f"""{new_k}, {k}, {v.shape}, {state_dict[new_k].shape}""" for k, v in tqdm(remaining_weights.items(), '''tf -> hf conversion''' ): a = [k.endswith(snake_case_ ) for ending in KEYS_TO_IGNORE] if any(snake_case_ ): continue a = REMAINING_PATTERNS a = rename_state_dict_key(snake_case_, snake_case_ ) if new_k not in state_dict and k != "pegasus/embeddings/position_embeddings": raise ValueError(f"""could not find new key {new_k} in state dict. (converted from {k})""" ) if any(True if i in k else False for i in ['''dense''', '''query''', '''key''', '''value'''] ): a = v.T a = torch.from_numpy(snake_case_ ) if k != "pegasus/embeddings/position_embeddings": assert v.shape == state_dict[new_k].shape, f"""{new_k}, {k}, {v.shape}, {state_dict[new_k].shape}""" a = mapping['''model.embed_positions.weight'''] a = mapping.pop('''model.embed_positions.weight''' ) a , a = torch_model.load_state_dict(snake_case_, strict=snake_case_ ) a = [ k for k in missing if k not in [ '''final_logits_bias''', '''model.encoder.embed_tokens.weight''', '''model.decoder.embed_tokens.weight''', '''lm_head.weight''', ] ] assert unexpected_missing == [], f"""no matches found for the following torch keys {unexpected_missing}""" assert extra == [], f"""no matches found for the following tf keys {extra}""" return torch_model def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Dict: """simple docstring""" a = tf.train.list_variables(snake_case_ ) a = {} a = ['''global_step'''] for name, shape in tqdm(snake_case_, desc='''converting tf checkpoint to dict''' ): a = any(pat in name for pat in ignore_name ) if skip_key: continue a = tf.train.load_variable(snake_case_, snake_case_ ) a = array return tf_weights def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> int: """simple docstring""" a = get_tf_weights_as_numpy(snake_case_ ) a = convert_bigbird_pegasus(snake_case_, snake_case_ ) torch_model.save_pretrained(snake_case_ ) if __name__ == "__main__": UpperCamelCase__ : str = argparse.ArgumentParser() parser.add_argument("""--tf_ckpt_path""", type=str, help="""passed to tf.train.list_variables""") parser.add_argument("""--save_dir""", default=None, type=str, help="""Path to the output PyTorch model.""") UpperCamelCase__ : int = parser.parse_args() UpperCamelCase__ : Tuple = {} convert_bigbird_pegasus_ckpt_to_pytorch(args.tf_ckpt_path, args.save_dir, config_update=config_update)
330
0
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 lowerCamelCase_ ( unittest.TestCase ): def __init__( self : Optional[Any] ,__lowerCamelCase : int ,__lowerCamelCase : str=13 ,__lowerCamelCase : int=7 ,__lowerCamelCase : Optional[Any]=True ,__lowerCamelCase : int=True ,__lowerCamelCase : List[str]=True ,__lowerCamelCase : Any=True ,__lowerCamelCase : List[Any]=99 ,__lowerCamelCase : int=32 ,__lowerCamelCase : Union[str, Any]=5 ,__lowerCamelCase : Dict=4 ,__lowerCamelCase : Any=37 ,__lowerCamelCase : Union[str, Any]="gelu" ,__lowerCamelCase : List[Any]=0.1 ,__lowerCamelCase : List[Any]=0.1 ,__lowerCamelCase : str=5_12 ,__lowerCamelCase : Tuple=16 ,__lowerCamelCase : Optional[Any]=2 ,__lowerCamelCase : Union[str, Any]=0.02 ,__lowerCamelCase : Union[str, Any]=4 ,): '''simple docstring''' a = parent a = batch_size a = seq_length a = is_training a = use_attention_mask a = use_token_type_ids a = use_labels a = vocab_size a = hidden_size a = num_hidden_layers a = num_attention_heads a = intermediate_size a = hidden_act a = hidden_dropout_prob a = attention_probs_dropout_prob a = max_position_embeddings a = type_vocab_size a = type_sequence_label_size a = initializer_range a = num_choices def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ): '''simple docstring''' a = ids_tensor([self.batch_size, self.seq_length] ,self.vocab_size ) a = None if self.use_attention_mask: a = random_attention_mask([self.batch_size, self.seq_length] ) a = 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_=UpperCamelCase__ ,) return config, input_ids, attention_mask def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ): '''simple docstring''' a = self.prepare_config_and_inputs() a = config_and_inputs a = {'''input_ids''': input_ids, '''attention_mask''': attention_mask} return config, inputs_dict @require_flax class lowerCamelCase_ ( __SCREAMING_SNAKE_CASE , unittest.TestCase ): SCREAMING_SNAKE_CASE_ = ( ( FlaxDistilBertModel, FlaxDistilBertForMaskedLM, FlaxDistilBertForMultipleChoice, FlaxDistilBertForQuestionAnswering, FlaxDistilBertForSequenceClassification, FlaxDistilBertForTokenClassification, FlaxDistilBertForQuestionAnswering, ) if is_flax_available() else () ) def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' a = FlaxDistilBertModelTester(self ) @slow def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ): '''simple docstring''' for model_class_name in self.all_model_classes: a = model_class_name.from_pretrained('''distilbert-base-uncased''' ) a = model(np.ones((1, 1) ) ) self.assertIsNotNone(UpperCamelCase__ ) @require_flax class lowerCamelCase_ ( unittest.TestCase ): @slow def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' a = FlaxDistilBertModel.from_pretrained('''distilbert-base-uncased''' ) a = np.array([[0, 3_45, 2_32, 3_28, 7_40, 1_40, 16_95, 69, 60_78, 15_88, 2]] ) a = np.array([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] ) a = model(UpperCamelCase__ ,attention_mask=UpperCamelCase__ )[0] a = (1, 11, 7_68) self.assertEqual(output.shape ,UpperCamelCase__ ) a = np.array([[[-0.1_639, 0.3_299, 0.1_648], [-0.1_746, 0.3_289, 0.1_710], [-0.1_884, 0.3_357, 0.1_810]]] ) self.assertTrue(jnp.allclose(output[:, 1:4, 1:4] ,UpperCamelCase__ ,atol=1e-4 ) )
367
import re def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> str: """simple docstring""" if len(re.findall('''[ATCG]''', snake_case_ ) ) != len(snake_case_ ): raise ValueError('''Invalid Strand''' ) return dna.translate(dna.maketrans('''ATCG''', '''TAGC''' ) ) if __name__ == "__main__": import doctest doctest.testmod()
330
0
"""simple docstring""" import shutil import tempfile import unittest from unittest.mock import patch from transformers import ( DefaultFlowCallback, IntervalStrategy, PrinterCallback, ProgressCallback, Trainer, TrainerCallback, TrainingArguments, is_torch_available, ) from transformers.testing_utils import require_torch if is_torch_available(): from transformers.trainer import DEFAULT_CALLBACKS from .test_trainer import RegressionDataset, RegressionModelConfig, RegressionPreTrainedModel class lowerCamelCase_ ( _a ): def __init__( self : Optional[Any] ): '''simple docstring''' a = [] def SCREAMING_SNAKE_CASE_ ( self : Dict ,__lowerCamelCase : Dict ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : int ,**__lowerCamelCase : Tuple ): '''simple docstring''' self.events.append('''on_init_end''' ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : int ,__lowerCamelCase : Tuple ,__lowerCamelCase : Dict ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' self.events.append('''on_train_begin''' ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : List[Any] ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : Optional[Any] ,**__lowerCamelCase : Optional[int] ): '''simple docstring''' self.events.append('''on_train_end''' ) def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ,__lowerCamelCase : Tuple ,__lowerCamelCase : Optional[int] ,__lowerCamelCase : List[Any] ,**__lowerCamelCase : Union[str, Any] ): '''simple docstring''' self.events.append('''on_epoch_begin''' ) def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : Optional[int] ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : Union[str, Any] ,**__lowerCamelCase : List[Any] ): '''simple docstring''' self.events.append('''on_epoch_end''' ) def SCREAMING_SNAKE_CASE_ ( self : List[Any] ,__lowerCamelCase : Any ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : List[str] ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' self.events.append('''on_step_begin''' ) def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ,__lowerCamelCase : int ,__lowerCamelCase : List[str] ,__lowerCamelCase : Union[str, Any] ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' self.events.append('''on_step_end''' ) def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : Any ,__lowerCamelCase : Union[str, Any] ,__lowerCamelCase : Union[str, Any] ,**__lowerCamelCase : List[str] ): '''simple docstring''' self.events.append('''on_evaluate''' ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : Union[str, Any] ,__lowerCamelCase : str ,__lowerCamelCase : Dict ,**__lowerCamelCase : Any ): '''simple docstring''' self.events.append('''on_predict''' ) def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : str ,__lowerCamelCase : Optional[Any] ,**__lowerCamelCase : Optional[int] ): '''simple docstring''' self.events.append('''on_save''' ) def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : Tuple ,__lowerCamelCase : List[str] ,__lowerCamelCase : Optional[Any] ,**__lowerCamelCase : Any ): '''simple docstring''' self.events.append('''on_log''' ) def SCREAMING_SNAKE_CASE_ ( self : Dict ,__lowerCamelCase : Optional[Any] ,__lowerCamelCase : List[Any] ,__lowerCamelCase : List[Any] ,**__lowerCamelCase : Union[str, Any] ): '''simple docstring''' self.events.append('''on_prediction_step''' ) @require_torch class lowerCamelCase_ ( unittest.TestCase ): def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ): '''simple docstring''' a = tempfile.mkdtemp() def SCREAMING_SNAKE_CASE_ ( self : List[str] ): '''simple docstring''' shutil.rmtree(self.output_dir ) def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : List[Any]=0 ,__lowerCamelCase : Optional[Any]=0 ,__lowerCamelCase : str=64 ,__lowerCamelCase : int=64 ,__lowerCamelCase : Tuple=None ,__lowerCamelCase : Optional[Any]=False ,**__lowerCamelCase : List[str] ): '''simple docstring''' a = RegressionDataset(length=__lowerCamelCase ) a = RegressionDataset(length=__lowerCamelCase ) a = RegressionModelConfig(a=__lowerCamelCase ,b=__lowerCamelCase ) a = RegressionPreTrainedModel(__lowerCamelCase ) a = TrainingArguments(self.output_dir ,disable_tqdm=__lowerCamelCase ,report_to=[] ,**__lowerCamelCase ) return Trainer( __lowerCamelCase ,__lowerCamelCase ,train_dataset=__lowerCamelCase ,eval_dataset=__lowerCamelCase ,callbacks=__lowerCamelCase ,) def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : List[str] ,__lowerCamelCase : Dict ): '''simple docstring''' self.assertEqual(len(__lowerCamelCase ) ,len(__lowerCamelCase ) ) # Order doesn't matter a = sorted(__lowerCamelCase ,key=lambda __lowerCamelCase : cb.__name__ if isinstance(__lowerCamelCase ,__lowerCamelCase ) else cb.__class__.__name__ ) a = sorted(__lowerCamelCase ,key=lambda __lowerCamelCase : cb.__name__ if isinstance(__lowerCamelCase ,__lowerCamelCase ) else cb.__class__.__name__ ) for cba, cba in zip(__lowerCamelCase ,__lowerCamelCase ): if isinstance(__lowerCamelCase ,__lowerCamelCase ) and isinstance(__lowerCamelCase ,__lowerCamelCase ): self.assertEqual(__lowerCamelCase ,__lowerCamelCase ) elif isinstance(__lowerCamelCase ,__lowerCamelCase ) and not isinstance(__lowerCamelCase ,__lowerCamelCase ): self.assertEqual(__lowerCamelCase ,cba.__class__ ) elif not isinstance(__lowerCamelCase ,__lowerCamelCase ) and isinstance(__lowerCamelCase ,__lowerCamelCase ): self.assertEqual(cba.__class__ ,__lowerCamelCase ) else: self.assertEqual(__lowerCamelCase ,__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ,__lowerCamelCase : Tuple ): '''simple docstring''' a = ['on_init_end', 'on_train_begin'] a = 0 a = len(trainer.get_eval_dataloader() ) a = ['on_prediction_step'] * len(trainer.get_eval_dataloader() ) + ['on_log', 'on_evaluate'] for _ in range(trainer.state.num_train_epochs ): expected_events.append('''on_epoch_begin''' ) for _ in range(__lowerCamelCase ): step += 1 expected_events += ["on_step_begin", "on_step_end"] if step % trainer.args.logging_steps == 0: expected_events.append('''on_log''' ) if trainer.args.evaluation_strategy == IntervalStrategy.STEPS and step % trainer.args.eval_steps == 0: expected_events += evaluation_events.copy() if step % trainer.args.save_steps == 0: expected_events.append('''on_save''' ) expected_events.append('''on_epoch_end''' ) if trainer.args.evaluation_strategy == IntervalStrategy.EPOCH: expected_events += evaluation_events.copy() expected_events += ["on_log", "on_train_end"] return expected_events def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ): '''simple docstring''' a = self.get_trainer() a = DEFAULT_CALLBACKS.copy() + [ProgressCallback] self.check_callbacks_equality(trainer.callback_handler.callbacks ,__lowerCamelCase ) # Callbacks passed at init are added to the default callbacks a = self.get_trainer(callbacks=[MyTestTrainerCallback] ) expected_callbacks.append(__lowerCamelCase ) self.check_callbacks_equality(trainer.callback_handler.callbacks ,__lowerCamelCase ) # TrainingArguments.disable_tqdm controls if use ProgressCallback or PrinterCallback a = self.get_trainer(disable_tqdm=__lowerCamelCase ) a = DEFAULT_CALLBACKS.copy() + [PrinterCallback] self.check_callbacks_equality(trainer.callback_handler.callbacks ,__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Tuple ): '''simple docstring''' a = DEFAULT_CALLBACKS.copy() + [ProgressCallback] a = self.get_trainer() # We can add, pop, or remove by class name trainer.remove_callback(__lowerCamelCase ) expected_callbacks.remove(__lowerCamelCase ) self.check_callbacks_equality(trainer.callback_handler.callbacks ,__lowerCamelCase ) a = self.get_trainer() a = trainer.pop_callback(__lowerCamelCase ) self.assertEqual(cb.__class__ ,__lowerCamelCase ) self.check_callbacks_equality(trainer.callback_handler.callbacks ,__lowerCamelCase ) trainer.add_callback(__lowerCamelCase ) expected_callbacks.insert(0 ,__lowerCamelCase ) self.check_callbacks_equality(trainer.callback_handler.callbacks ,__lowerCamelCase ) # We can also add, pop, or remove by instance a = self.get_trainer() a = trainer.callback_handler.callbacks[0] trainer.remove_callback(__lowerCamelCase ) expected_callbacks.remove(__lowerCamelCase ) self.check_callbacks_equality(trainer.callback_handler.callbacks ,__lowerCamelCase ) a = self.get_trainer() a = trainer.callback_handler.callbacks[0] a = trainer.pop_callback(__lowerCamelCase ) self.assertEqual(__lowerCamelCase ,__lowerCamelCase ) self.check_callbacks_equality(trainer.callback_handler.callbacks ,__lowerCamelCase ) trainer.add_callback(__lowerCamelCase ) expected_callbacks.insert(0 ,__lowerCamelCase ) self.check_callbacks_equality(trainer.callback_handler.callbacks ,__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' import warnings # XXX: for now ignore scatter_gather warnings in this test since it's not relevant to what's being tested warnings.simplefilter(action='''ignore''' ,category=__lowerCamelCase ) a = self.get_trainer(callbacks=[MyTestTrainerCallback] ) trainer.train() a = trainer.callback_handler.callbacks[-2].events self.assertEqual(__lowerCamelCase ,self.get_expected_events(__lowerCamelCase ) ) # Independent log/save/eval a = self.get_trainer(callbacks=[MyTestTrainerCallback] ,logging_steps=5 ) trainer.train() a = trainer.callback_handler.callbacks[-2].events self.assertEqual(__lowerCamelCase ,self.get_expected_events(__lowerCamelCase ) ) a = self.get_trainer(callbacks=[MyTestTrainerCallback] ,save_steps=5 ) trainer.train() a = trainer.callback_handler.callbacks[-2].events self.assertEqual(__lowerCamelCase ,self.get_expected_events(__lowerCamelCase ) ) a = self.get_trainer(callbacks=[MyTestTrainerCallback] ,eval_steps=5 ,evaluation_strategy='''steps''' ) trainer.train() a = trainer.callback_handler.callbacks[-2].events self.assertEqual(__lowerCamelCase ,self.get_expected_events(__lowerCamelCase ) ) a = self.get_trainer(callbacks=[MyTestTrainerCallback] ,evaluation_strategy='''epoch''' ) trainer.train() a = trainer.callback_handler.callbacks[-2].events self.assertEqual(__lowerCamelCase ,self.get_expected_events(__lowerCamelCase ) ) # A bit of everything a = self.get_trainer( callbacks=[MyTestTrainerCallback] ,logging_steps=3 ,save_steps=10 ,eval_steps=5 ,evaluation_strategy='''steps''' ,) trainer.train() a = trainer.callback_handler.callbacks[-2].events self.assertEqual(__lowerCamelCase ,self.get_expected_events(__lowerCamelCase ) ) # warning should be emitted for duplicated callbacks with patch('''transformers.trainer_callback.logger.warning''' ) as warn_mock: a = self.get_trainer( callbacks=[MyTestTrainerCallback, MyTestTrainerCallback] ,) assert str(__lowerCamelCase ) in warn_mock.call_args[0][0]
368
from __future__ import annotations from collections.abc import Sequence from typing import Literal def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> str | Literal[False]: """simple docstring""" a = list(snake_case_ ) a = list(snake_case_ ) a = 0 for i in range(len(snake_case_ ) ): if lista[i] != lista[i]: count += 1 a = '''_''' if count > 1: return False else: return "".join(snake_case_ ) def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> list[str]: """simple docstring""" a = [] while True: a = ['''$'''] * len(snake_case_ ) a = [] for i in range(len(snake_case_ ) ): for j in range(i + 1, len(snake_case_ ) ): a = compare_string(binary[i], binary[j] ) if k is False: a = '''*''' a = '''*''' temp.append('''X''' ) for i in range(len(snake_case_ ) ): if checka[i] == "$": pi.append(binary[i] ) if len(snake_case_ ) == 0: return pi a = list(set(snake_case_ ) ) def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> list[str]: """simple docstring""" a = [] for minterm in minterms: a = '''''' for _ in range(snake_case_ ): a = str(minterm % 2 ) + string minterm //= 2 temp.append(snake_case_ ) return temp def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_ ) -> bool: """simple docstring""" a = list(snake_case_ ) a = list(snake_case_ ) a = 0 for i in range(len(snake_case_ ) ): if lista[i] != lista[i]: count_n += 1 return count_n == count def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> list[str]: """simple docstring""" a = [] a = [0] * len(snake_case_ ) for i in range(len(chart[0] ) ): a = 0 a = -1 for j in range(len(snake_case_ ) ): if chart[j][i] == 1: count += 1 a = j if count == 1: a = 1 for i in range(len(snake_case_ ) ): if select[i] == 1: for j in range(len(chart[0] ) ): if chart[i][j] == 1: for k in range(len(snake_case_ ) ): a = 0 temp.append(prime_implicants[i] ) while True: a = 0 a = -1 a = 0 for i in range(len(snake_case_ ) ): a = chart[i].count(1 ) if count_n > max_n: a = count_n a = i if max_n == 0: return temp temp.append(prime_implicants[rem] ) for i in range(len(chart[0] ) ): if chart[rem][i] == 1: for j in range(len(snake_case_ ) ): a = 0 def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> list[list[int]]: """simple docstring""" a = [[0 for x in range(len(snake_case_ ) )] for x in range(len(snake_case_ ) )] for i in range(len(snake_case_ ) ): a = prime_implicants[i].count('''_''' ) for j in range(len(snake_case_ ) ): if is_for_table(prime_implicants[i], binary[j], snake_case_ ): a = 1 return chart def SCREAMING_SNAKE_CASE__ ( ) -> None: """simple docstring""" a = int(input('''Enter the no. of variables\n''' ) ) a = [ float(snake_case_ ) for x in input( '''Enter the decimal representation of Minterms \'Spaces Separated\'\n''' ).split() ] a = decimal_to_binary(snake_case_, snake_case_ ) a = check(snake_case_ ) print('''Prime Implicants are:''' ) print(snake_case_ ) a = prime_implicant_chart(snake_case_, snake_case_ ) a = selection(snake_case_, snake_case_ ) print('''Essential Prime Implicants are:''' ) print(snake_case_ ) if __name__ == "__main__": import doctest doctest.testmod() main()
330
0
def SCREAMING_SNAKE_CASE__ ( snake_case_ = "The quick brown fox jumps over the lazy dog", ) -> List[Any]: """simple docstring""" a = set() # Replace all the whitespace in our sentence a = input_str.replace(''' ''', '''''' ) for alpha in input_str: if "a" <= alpha.lower() <= "z": frequency.add(alpha.lower() ) return len(__UpperCamelCase ) == 2_6 def SCREAMING_SNAKE_CASE__ ( snake_case_ = "The quick brown fox jumps over the lazy dog", ) -> Tuple: """simple docstring""" a = [False] * 2_6 for char in input_str: if char.islower(): a = True elif char.isupper(): a = True return all(__UpperCamelCase ) def SCREAMING_SNAKE_CASE__ ( snake_case_ = "The quick brown fox jumps over the lazy dog", ) -> Dict: """simple docstring""" return len({char for char in input_str.lower() if char.isalpha()} ) == 2_6 def SCREAMING_SNAKE_CASE__ ( ) -> Dict: """simple docstring""" from timeit import timeit a = '''from __main__ import is_pangram, is_pangram_faster, is_pangram_fastest''' print(timeit('''is_pangram()''', setup=__UpperCamelCase ) ) print(timeit('''is_pangram_faster()''', setup=__UpperCamelCase ) ) print(timeit('''is_pangram_fastest()''', setup=__UpperCamelCase ) ) # 5.348480500048026, 2.6477354579837993, 1.8470395830227062 # 5.036091582966037, 2.644472333951853, 1.8869528750656173 if __name__ == "__main__": import doctest doctest.testmod() benchmark()
369
from typing import List, Union import numpy as np from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_torch_available(): import torch from ..models.auto.modeling_auto import MODEL_FOR_DEPTH_ESTIMATION_MAPPING UpperCamelCase__ : List[str] = logging.get_logger(__name__) @add_end_docstrings(a_ ) class lowerCamelCase_ ( a_ ): def __init__( self : int ,*__lowerCamelCase : str ,**__lowerCamelCase : Optional[Any] ): '''simple docstring''' super().__init__(*__lowerCamelCase ,**__lowerCamelCase ) requires_backends(self ,'''vision''' ) self.check_model_type(__lowerCamelCase ) def __call__( self : int ,__lowerCamelCase : Union[str, List[str], "Image.Image", List["Image.Image"]] ,**__lowerCamelCase : str ): '''simple docstring''' return super().__call__(__lowerCamelCase ,**__lowerCamelCase ) def SCREAMING_SNAKE_CASE_ ( self : Any ,**__lowerCamelCase : Dict ): '''simple docstring''' return {}, {}, {} def SCREAMING_SNAKE_CASE_ ( self : int ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = load_image(__lowerCamelCase ) a = image.size a = self.image_processor(images=__lowerCamelCase ,return_tensors=self.framework ) return model_inputs def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = self.model(**__lowerCamelCase ) return model_outputs def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = model_outputs.predicted_depth a = torch.nn.functional.interpolate( predicted_depth.unsqueeze(1 ) ,size=self.image_size[::-1] ,mode='''bicubic''' ,align_corners=__lowerCamelCase ) a = prediction.squeeze().cpu().numpy() a = (output * 2_55 / np.max(__lowerCamelCase )).astype('''uint8''' ) a = Image.fromarray(__lowerCamelCase ) a = {} a = predicted_depth a = depth return output_dict
330
0
from collections import UserDict from typing import Union import numpy as np import requests from ..utils import ( add_end_docstrings, logging, ) from .audio_classification import ffmpeg_read from .base import PIPELINE_INIT_ARGS, Pipeline UpperCamelCase__ = logging.get_logger(__name__) @add_end_docstrings(_lowerCAmelCase ) class lowerCamelCase_ ( _lowerCAmelCase ): def __init__( self : Optional[int] ,**__lowerCamelCase : Dict ): '''simple docstring''' super().__init__(**_lowercase ) if self.framework != "pt": raise ValueError(F"""The {self.__class__} is only available in PyTorch.""" ) # No specific FOR_XXX available yet def __call__( self : str ,__lowerCamelCase : Union[np.ndarray, bytes, str] ,**__lowerCamelCase : List[Any] ): '''simple docstring''' return super().__call__(_lowercase ,**_lowercase ) def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ,**__lowerCamelCase : List[Any] ): '''simple docstring''' a = {} if "candidate_labels" in kwargs: a = kwargs['''candidate_labels'''] if "hypothesis_template" in kwargs: a = kwargs['''hypothesis_template'''] return preprocess_params, {}, {} def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ,__lowerCamelCase : Any ,__lowerCamelCase : Any=None ,__lowerCamelCase : Union[str, Any]="This is a sound of {}." ): '''simple docstring''' if isinstance(_lowercase ,_lowercase ): if audio.startswith('''http://''' ) or audio.startswith('''https://''' ): # We need to actually check for a real protocol, otherwise it's impossible to use a local file # like http_huggingface_co.png a = requests.get(_lowercase ).content else: with open(_lowercase ,'''rb''' ) as f: a = f.read() if isinstance(_lowercase ,_lowercase ): a = ffmpeg_read(_lowercase ,self.feature_extractor.sampling_rate ) if not isinstance(_lowercase ,np.ndarray ): raise ValueError('''We expect a numpy ndarray as input''' ) if len(audio.shape ) != 1: raise ValueError('''We expect a single channel audio input for ZeroShotAudioClassificationPipeline''' ) a = self.feature_extractor( [audio] ,sampling_rate=self.feature_extractor.sampling_rate ,return_tensors='''pt''' ) a = candidate_labels a = [hypothesis_template.format(_lowercase ) for x in candidate_labels] a = self.tokenizer(_lowercase ,return_tensors=self.framework ,padding=_lowercase ) a = [text_inputs] return inputs def SCREAMING_SNAKE_CASE_ ( self : Any ,__lowerCamelCase : List[Any] ): '''simple docstring''' a = model_inputs.pop('''candidate_labels''' ) a = model_inputs.pop('''text_inputs''' ) if isinstance(text_inputs[0] ,_lowercase ): a = text_inputs[0] else: # Batching case. a = text_inputs[0][0] a = self.model(**_lowercase ,**_lowercase ) a = { '''candidate_labels''': candidate_labels, '''logits''': outputs.logits_per_audio, } return model_outputs def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : int ): '''simple docstring''' a = model_outputs.pop('''candidate_labels''' ) a = model_outputs['''logits'''][0] if self.framework == "pt": a = logits.softmax(dim=0 ) a = probs.tolist() else: raise ValueError('''`tf` framework not supported.''' ) a = [ {'''score''': score, '''label''': candidate_label} for score, candidate_label in sorted(zip(_lowercase ,_lowercase ) ,key=lambda __lowerCamelCase : -x[0] ) ] return result
370
from dataclasses import dataclass, field from typing import ClassVar, Dict from ..features import Features, Value from .base import TaskTemplate @dataclass(frozen=a_ ) class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = field(default='language-modeling' , metadata={'include_in_asdict_even_if_is_default': True} ) SCREAMING_SNAKE_CASE_ = Features({'text': Value('string' )} ) SCREAMING_SNAKE_CASE_ = Features({} ) SCREAMING_SNAKE_CASE_ = "text" @property def SCREAMING_SNAKE_CASE_ ( self : int ): '''simple docstring''' return {self.text_column: "text"}
330
0
from __future__ import annotations def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> Tuple: """simple docstring""" return len(set(a__ ) ) == len(a__ ) if __name__ == "__main__": import doctest doctest.testmod()
371
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__ : Union[str, Any] = logging.get_logger(__name__) UpperCamelCase__ : Union[str, Any] = { """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_ ): SCREAMING_SNAKE_CASE_ = 'yolos' def __init__( self : Union[str, Any] ,__lowerCamelCase : int=7_68 ,__lowerCamelCase : Dict=12 ,__lowerCamelCase : Union[str, Any]=12 ,__lowerCamelCase : List[Any]=30_72 ,__lowerCamelCase : int="gelu" ,__lowerCamelCase : int=0.0 ,__lowerCamelCase : str=0.0 ,__lowerCamelCase : Optional[Any]=0.02 ,__lowerCamelCase : int=1e-12 ,__lowerCamelCase : Any=[5_12, 8_64] ,__lowerCamelCase : Tuple=16 ,__lowerCamelCase : int=3 ,__lowerCamelCase : Tuple=True ,__lowerCamelCase : Optional[int]=1_00 ,__lowerCamelCase : List[Any]=True ,__lowerCamelCase : List[str]=False ,__lowerCamelCase : int=1 ,__lowerCamelCase : List[Any]=5 ,__lowerCamelCase : Optional[int]=2 ,__lowerCamelCase : int=5 ,__lowerCamelCase : str=2 ,__lowerCamelCase : Tuple=0.1 ,**__lowerCamelCase : List[Any] ,): '''simple docstring''' super().__init__(**__lowerCamelCase ) a = hidden_size a = num_hidden_layers a = num_attention_heads a = intermediate_size a = hidden_act a = hidden_dropout_prob a = attention_probs_dropout_prob a = initializer_range a = layer_norm_eps a = image_size a = patch_size a = num_channels a = qkv_bias a = num_detection_tokens a = use_mid_position_embeddings a = auxiliary_loss # Hungarian matcher a = class_cost a = bbox_cost a = giou_cost # Loss coefficients a = bbox_loss_coefficient a = giou_loss_coefficient a = eos_coefficient class lowerCamelCase_ ( a_ ): SCREAMING_SNAKE_CASE_ = version.parse('1.11' ) @property def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' return OrderedDict( [ ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}), ] ) @property def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ): '''simple docstring''' return 1e-4 @property def SCREAMING_SNAKE_CASE_ ( self : str ): '''simple docstring''' return 12
330
0
import os from shutil import copyfile from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import AddedToken, BatchEncoding, PreTrainedTokenizer from ...utils import logging UpperCamelCase__ : Union[str, Any] = logging.get_logger(__name__) UpperCamelCase__ : List[str] = """▁""" UpperCamelCase__ : Dict = {"""vocab_file""": """sentencepiece.bpe.model"""} UpperCamelCase__ : Union[str, Any] = { """vocab_file""": { """facebook/mbart-large-en-ro""": ( """https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/sentencepiece.bpe.model""" ), """facebook/mbart-large-cc25""": ( """https://huggingface.co/facebook/mbart-large-cc25/resolve/main/sentencepiece.bpe.model""" ), } } UpperCamelCase__ : Tuple = { """facebook/mbart-large-en-ro""": 1_024, """facebook/mbart-large-cc25""": 1_024, } # fmt: off UpperCamelCase__ : int = ["""ar_AR""", """cs_CZ""", """de_DE""", """en_XX""", """es_XX""", """et_EE""", """fi_FI""", """fr_XX""", """gu_IN""", """hi_IN""", """it_IT""", """ja_XX""", """kk_KZ""", """ko_KR""", """lt_LT""", """lv_LV""", """my_MM""", """ne_NP""", """nl_XX""", """ro_RO""", """ru_RU""", """si_LK""", """tr_TR""", """vi_VN""", """zh_CN"""] class lowerCamelCase_ ( snake_case_ ): SCREAMING_SNAKE_CASE_ = VOCAB_FILES_NAMES SCREAMING_SNAKE_CASE_ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES SCREAMING_SNAKE_CASE_ = PRETRAINED_VOCAB_FILES_MAP SCREAMING_SNAKE_CASE_ = ["input_ids", "attention_mask"] SCREAMING_SNAKE_CASE_ = [] SCREAMING_SNAKE_CASE_ = [] def __init__( self : Dict ,__lowerCamelCase : Optional[int] ,__lowerCamelCase : List[str]="<s>" ,__lowerCamelCase : Optional[int]="</s>" ,__lowerCamelCase : List[str]="</s>" ,__lowerCamelCase : Any="<s>" ,__lowerCamelCase : Optional[int]="<unk>" ,__lowerCamelCase : Union[str, Any]="<pad>" ,__lowerCamelCase : Any="<mask>" ,__lowerCamelCase : str=None ,__lowerCamelCase : Union[str, Any]=None ,__lowerCamelCase : str=None ,__lowerCamelCase : Optional[Dict[str, Any]] = None ,__lowerCamelCase : Dict=None ,**__lowerCamelCase : Union[str, Any] ,): '''simple docstring''' a = AddedToken(_A ,lstrip=_A ,rstrip=_A ) if isinstance(_A ,_A ) else mask_token a = {} if sp_model_kwargs is None else sp_model_kwargs super().__init__( bos_token=_A ,eos_token=_A ,unk_token=_A ,sep_token=_A ,cls_token=_A ,pad_token=_A ,mask_token=_A ,tokenizer_file=_A ,src_lang=_A ,tgt_lang=_A ,additional_special_tokens=_A ,sp_model_kwargs=self.sp_model_kwargs ,**_A ,) a = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(str(_A ) ) a = vocab_file # Original fairseq vocab and spm vocab must be "aligned": # Vocab | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 # -------- | ------- | ------- | ------ | ------- | --- | --- | --- | ----- | ----- | ---- # fairseq | '<s>' | '<pad>' | '</s>' | '<unk>' | ',' | '.' | '▁' | 's' | '▁de' | '-' # spm | '<unk>' | '<s>' | '</s>' | ',' | '.' | '▁' | 's' | '▁de' | '-' | '▁a' # Mimic fairseq token-to-id alignment for the first 4 token a = {'<s>': 0, '<pad>': 1, '</s>': 2, '<unk>': 3} # The first "real" token "," has position 4 in the original fairseq vocab and position 3 in the spm vocab a = 1 a = len(self.sp_model ) a = { code: self.sp_model_size + i + self.fairseq_offset for i, code in enumerate(_A ) } a = {v: k for k, v in self.lang_code_to_id.items()} a = len(self.sp_model ) + len(self.lang_code_to_id ) + self.fairseq_offset self.fairseq_tokens_to_ids.update(self.lang_code_to_id ) a = {v: k for k, v in self.fairseq_tokens_to_ids.items()} a = list(self.lang_code_to_id.keys() ) if additional_special_tokens is not None: # Only add those special tokens if they are not already there. self._additional_special_tokens.extend( [t for t in additional_special_tokens if t not in self._additional_special_tokens] ) a = src_lang if src_lang is not None else 'en_XX' a = self.lang_code_to_id[self._src_lang] a = tgt_lang self.set_src_lang_special_tokens(self._src_lang ) def __getstate__( self : int ): '''simple docstring''' a = self.__dict__.copy() a = None a = self.sp_model.serialized_model_proto() return state def __setstate__( self : Optional[Any] ,__lowerCamelCase : str ): '''simple docstring''' a = d # for backward compatibility if not hasattr(self ,'''sp_model_kwargs''' ): a = {} a = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.LoadFromSerializedProto(self.sp_model_proto ) @property def SCREAMING_SNAKE_CASE_ ( self : List[Any] ): '''simple docstring''' return len(self.sp_model ) + len(self.lang_code_to_id ) + self.fairseq_offset + 1 # Plus 1 for the mask token @property def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ): '''simple docstring''' return self._src_lang @src_lang.setter def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : str ): '''simple docstring''' a = new_src_lang self.set_src_lang_special_tokens(self._src_lang ) def SCREAMING_SNAKE_CASE_ ( self : Dict ,__lowerCamelCase : List[int] ,__lowerCamelCase : Optional[List[int]] = None ,__lowerCamelCase : bool = False ): '''simple docstring''' if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=_A ,token_ids_a=_A ,already_has_special_tokens=_A ) a = [1] * len(self.prefix_tokens ) a = [1] * len(self.suffix_tokens ) if token_ids_a is None: return prefix_ones + ([0] * len(_A )) + suffix_ones return prefix_ones + ([0] * len(_A )) + ([0] * len(_A )) + suffix_ones def SCREAMING_SNAKE_CASE_ ( self : List[Any] ,__lowerCamelCase : List[int] ,__lowerCamelCase : Optional[List[int]] = None ): '''simple docstring''' if token_ids_a is None: return self.prefix_tokens + token_ids_a + self.suffix_tokens # We don't expect to process pairs, but leave the pair logic for API consistency return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens def SCREAMING_SNAKE_CASE_ ( self : List[Any] ,__lowerCamelCase : List[int] ,__lowerCamelCase : Optional[List[int]] = None ): '''simple docstring''' a = [self.sep_token_id] a = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0] def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : Dict ,__lowerCamelCase : str ,__lowerCamelCase : Optional[str] ,__lowerCamelCase : Optional[str] ,**__lowerCamelCase : Optional[int] ): '''simple docstring''' if src_lang is None or tgt_lang is None: raise ValueError('''Translation requires a `src_lang` and a `tgt_lang` for this model''' ) a = src_lang a = self(_A ,add_special_tokens=_A ,return_tensors=_A ,**_A ) a = self.convert_tokens_to_ids(_A ) a = tgt_lang_id return inputs def SCREAMING_SNAKE_CASE_ ( self : Dict ): '''simple docstring''' a = {self.convert_ids_to_tokens(_A ): i for i in range(self.vocab_size )} vocab.update(self.added_tokens_encoder ) return vocab def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ,__lowerCamelCase : str ): '''simple docstring''' return self.sp_model.encode(_A ,out_type=_A ) def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ,__lowerCamelCase : List[str] ): '''simple docstring''' if token in self.fairseq_tokens_to_ids: return self.fairseq_tokens_to_ids[token] a = self.sp_model.PieceToId(_A ) # Need to return unknown token if the SP model returned 0 return spm_id + self.fairseq_offset if spm_id else self.unk_token_id def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] ,__lowerCamelCase : List[str] ): '''simple docstring''' if index in self.fairseq_ids_to_tokens: return self.fairseq_ids_to_tokens[index] return self.sp_model.IdToPiece(index - self.fairseq_offset ) def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : Union[str, Any] ): '''simple docstring''' a = ''.join(_A ).replace(_A ,''' ''' ).strip() return out_string def SCREAMING_SNAKE_CASE_ ( self : Tuple ,__lowerCamelCase : str ,__lowerCamelCase : Optional[str] = None ): '''simple docstring''' if not os.path.isdir(_A ): logger.error(F"""Vocabulary path ({save_directory}) should be a directory""" ) return a = os.path.join( _A ,(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file'''] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(_A ) and os.path.isfile(self.vocab_file ): copyfile(self.vocab_file ,_A ) elif not os.path.isfile(self.vocab_file ): with open(_A ,'''wb''' ) as fi: a = self.sp_model.serialized_model_proto() fi.write(_A ) return (out_vocab_file,) def SCREAMING_SNAKE_CASE_ ( self : Optional[int] ,__lowerCamelCase : List[str] ,__lowerCamelCase : str = "en_XX" ,__lowerCamelCase : Optional[List[str]] = None ,__lowerCamelCase : str = "ro_RO" ,**__lowerCamelCase : str ,): '''simple docstring''' a = src_lang a = tgt_lang return super().prepare_seqaseq_batch(_A ,_A ,**_A ) def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ): '''simple docstring''' return self.set_src_lang_special_tokens(self.src_lang ) def SCREAMING_SNAKE_CASE_ ( self : Optional[Any] ): '''simple docstring''' return self.set_tgt_lang_special_tokens(self.tgt_lang ) def SCREAMING_SNAKE_CASE_ ( self : List[str] ,__lowerCamelCase : Optional[Any] ): '''simple docstring''' a = self.lang_code_to_id[src_lang] a = [] a = [self.eos_token_id, self.cur_lang_code] def SCREAMING_SNAKE_CASE_ ( self : str ,__lowerCamelCase : str ): '''simple docstring''' a = self.lang_code_to_id[lang] a = [] a = [self.eos_token_id, self.cur_lang_code]
350
def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> int: """simple docstring""" a = '''''' for i in table: res += inp[i - 1] return res def SCREAMING_SNAKE_CASE__ ( snake_case_ ) -> int: """simple docstring""" return data[1:] + data[0] def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> List[str]: """simple docstring""" a = '''''' for i in range(len(snake_case_ ) ): if a[i] == b[i]: res += "0" else: res += "1" return res def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_ ) -> Dict: """simple docstring""" a = int('''0b''' + data[0] + data[-1], 2 ) a = int('''0b''' + data[1:3], 2 ) return bin(s[row][col] )[2:] def SCREAMING_SNAKE_CASE__ ( snake_case_, snake_case_, snake_case_, snake_case_, snake_case_ ) -> Optional[int]: """simple docstring""" a = message[:4] a = message[4:] a = apply_table(snake_case_, snake_case_ ) a = xor(snake_case_, snake_case_ ) a = apply_sbox(snake_case_, temp[:4] ) # noqa: E741 a = apply_sbox(snake_case_, temp[4:] ) a = '''0''' * (2 - len(snake_case_ )) + l # noqa: E741 a = '''0''' * (2 - len(snake_case_ )) + r a = apply_table(l + r, snake_case_ ) a = xor(snake_case_, snake_case_ ) return temp + right if __name__ == "__main__": UpperCamelCase__ : int = input("""Enter 10 bit key: """) UpperCamelCase__ : Union[str, Any] = input("""Enter 8 bit message: """) UpperCamelCase__ : Dict = [6, 3, 7, 4, 8, 5, 10, 9] UpperCamelCase__ : Union[str, Any] = [3, 5, 2, 7, 4, 10, 1, 9, 8, 6] UpperCamelCase__ : Optional[int] = [2, 4, 3, 1] UpperCamelCase__ : List[Any] = [2, 6, 3, 1, 4, 8, 5, 7] UpperCamelCase__ : str = [4, 1, 3, 5, 7, 2, 8, 6] UpperCamelCase__ : List[Any] = [4, 1, 2, 3, 2, 3, 4, 1] UpperCamelCase__ : int = [[1, 0, 3, 2], [3, 2, 1, 0], [0, 2, 1, 3], [3, 1, 3, 2]] UpperCamelCase__ : Dict = [[0, 1, 2, 3], [2, 0, 1, 3], [3, 0, 1, 0], [2, 1, 0, 3]] # key generation UpperCamelCase__ : Optional[Any] = apply_table(key, paa_table) UpperCamelCase__ : str = temp[:5] UpperCamelCase__ : List[Any] = temp[5:] UpperCamelCase__ : Dict = left_shift(left) UpperCamelCase__ : Any = left_shift(right) UpperCamelCase__ : Optional[Any] = apply_table(left + right, pa_table) UpperCamelCase__ : List[str] = left_shift(left) UpperCamelCase__ : int = left_shift(right) UpperCamelCase__ : List[str] = left_shift(left) UpperCamelCase__ : Dict = left_shift(right) UpperCamelCase__ : List[str] = apply_table(left + right, pa_table) # encryption UpperCamelCase__ : Tuple = apply_table(message, IP) UpperCamelCase__ : Optional[Any] = function(expansion, sa, sa, keya, temp) UpperCamelCase__ : Optional[int] = temp[4:] + temp[:4] UpperCamelCase__ : Any = function(expansion, sa, sa, keya, temp) UpperCamelCase__ : Tuple = apply_table(temp, IP_inv) print("""Cipher text is:""", CT) # decryption UpperCamelCase__ : Union[str, Any] = apply_table(CT, IP) UpperCamelCase__ : List[str] = function(expansion, sa, sa, keya, temp) UpperCamelCase__ : Optional[Any] = temp[4:] + temp[:4] UpperCamelCase__ : Optional[int] = function(expansion, sa, sa, keya, temp) UpperCamelCase__ : Any = apply_table(temp, IP_inv) print("""Plain text after decypting is:""", PT)
330
0