code
stringlengths
87
55.2k
code_codestyle
int64
0
349
style_context
stringlengths
135
49.1k
style_context_codestyle
int64
0
349
label
int64
0
1
from __future__ import annotations import time from math import sqrt # 1 for manhattan, 0 for euclidean UpperCAmelCase__ = 0 UpperCAmelCase__ = [ [0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0], # 0 are free path whereas 1's are obstacles [0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0], ] UpperCAmelCase__ = [[-1, 0], [0, -1], [1, 0], [0, 1]] # up, left, down, right UpperCAmelCase__ = tuple[int, int] class __lowerCAmelCase : def __init__( self : Optional[int] , A : int , A : int , A : int , A : int , A : int , A : Node | None , ) -> None: """simple docstring""" _UpperCAmelCase = pos_x _UpperCAmelCase = pos_y _UpperCAmelCase = (pos_y, pos_x) _UpperCAmelCase = goal_x _UpperCAmelCase = goal_y _UpperCAmelCase = g_cost _UpperCAmelCase = parent _UpperCAmelCase = self.calculate_heuristic() _UpperCAmelCase = self.g_cost + self.h_cost def _lowerCamelCase ( self : int) -> float: """simple docstring""" _UpperCAmelCase = self.pos_x - self.goal_x _UpperCAmelCase = self.pos_y - self.goal_y if HEURISTIC == 1: return abs(A) + abs(A) else: return sqrt(dy**2 + dx**2) def __lt__( self : int , A : Node) -> bool: """simple docstring""" return self.f_cost < other.f_cost class __lowerCAmelCase : def __init__( self : Union[str, Any] , A : TPosition , A : TPosition) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = Node(start[1] , start[0] , goal[1] , goal[0] , 0 , A) _UpperCAmelCase = Node(goal[1] , goal[0] , goal[1] , goal[0] , 9_99_99 , A) _UpperCAmelCase = [self.start] _UpperCAmelCase = [] _UpperCAmelCase = False def _lowerCamelCase ( self : List[Any]) -> list[TPosition]: """simple docstring""" while self.open_nodes: # Open Nodes are sorted using __lt__ self.open_nodes.sort() _UpperCAmelCase = self.open_nodes.pop(0) if current_node.pos == self.target.pos: return self.retrace_path(A) self.closed_nodes.append(A) _UpperCAmelCase = self.get_successors(A) for child_node in successors: if child_node in self.closed_nodes: continue if child_node not in self.open_nodes: self.open_nodes.append(A) else: # retrieve the best current path _UpperCAmelCase = self.open_nodes.pop(self.open_nodes.index(A)) if child_node.g_cost < better_node.g_cost: self.open_nodes.append(A) else: self.open_nodes.append(A) return [self.start.pos] def _lowerCamelCase ( self : List[str] , A : Node) -> list[Node]: """simple docstring""" _UpperCAmelCase = [] for action in delta: _UpperCAmelCase = parent.pos_x + action[1] _UpperCAmelCase = parent.pos_y + action[0] if not (0 <= pos_x <= len(grid[0]) - 1 and 0 <= pos_y <= len(A) - 1): continue if grid[pos_y][pos_x] != 0: continue successors.append( Node( A , A , self.target.pos_y , self.target.pos_x , parent.g_cost + 1 , A , )) return successors def _lowerCamelCase ( self : Optional[Any] , A : Node | None) -> list[TPosition]: """simple docstring""" _UpperCAmelCase = node _UpperCAmelCase = [] while current_node is not None: path.append((current_node.pos_y, current_node.pos_x)) _UpperCAmelCase = current_node.parent path.reverse() return path class __lowerCAmelCase : def __init__( self : Union[str, Any] , A : TPosition , A : TPosition) -> None: """simple docstring""" _UpperCAmelCase = AStar(A , A) _UpperCAmelCase = AStar(A , A) _UpperCAmelCase = False def _lowerCamelCase ( self : Union[str, Any]) -> list[TPosition]: """simple docstring""" while self.fwd_astar.open_nodes or self.bwd_astar.open_nodes: self.fwd_astar.open_nodes.sort() self.bwd_astar.open_nodes.sort() _UpperCAmelCase = self.fwd_astar.open_nodes.pop(0) _UpperCAmelCase = self.bwd_astar.open_nodes.pop(0) if current_bwd_node.pos == current_fwd_node.pos: return self.retrace_bidirectional_path( A , A) self.fwd_astar.closed_nodes.append(A) self.bwd_astar.closed_nodes.append(A) _UpperCAmelCase = current_bwd_node _UpperCAmelCase = current_fwd_node _UpperCAmelCase = { self.fwd_astar: self.fwd_astar.get_successors(A), self.bwd_astar: self.bwd_astar.get_successors(A), } for astar in [self.fwd_astar, self.bwd_astar]: for child_node in successors[astar]: if child_node in astar.closed_nodes: continue if child_node not in astar.open_nodes: astar.open_nodes.append(A) else: # retrieve the best current path _UpperCAmelCase = astar.open_nodes.pop( astar.open_nodes.index(A)) if child_node.g_cost < better_node.g_cost: astar.open_nodes.append(A) else: astar.open_nodes.append(A) return [self.fwd_astar.start.pos] def _lowerCamelCase ( self : Tuple , A : Node , A : Node) -> list[TPosition]: """simple docstring""" _UpperCAmelCase = self.fwd_astar.retrace_path(A) _UpperCAmelCase = self.bwd_astar.retrace_path(A) bwd_path.pop() bwd_path.reverse() _UpperCAmelCase = fwd_path + bwd_path return path if __name__ == "__main__": # all coordinates are given in format [y,x] UpperCAmelCase__ = (0, 0) UpperCAmelCase__ = (len(grid) - 1, len(grid[0]) - 1) for elem in grid: print(elem) UpperCAmelCase__ = time.time() UpperCAmelCase__ = AStar(init, goal) UpperCAmelCase__ = a_star.search() UpperCAmelCase__ = time.time() - start_time print(f"""AStar execution time = {end_time:f} seconds""") UpperCAmelCase__ = time.time() UpperCAmelCase__ = BidirectionalAStar(init, goal) UpperCAmelCase__ = time.time() - bd_start_time print(f"""BidirectionalAStar execution time = {bd_end_time:f} seconds""")
339
import unittest import numpy as np from transformers import RoFormerConfig, 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.roformer.modeling_flax_roformer import ( FlaxRoFormerForMaskedLM, FlaxRoFormerForMultipleChoice, FlaxRoFormerForQuestionAnswering, FlaxRoFormerForSequenceClassification, FlaxRoFormerForTokenClassification, FlaxRoFormerModel, ) class __lowerCAmelCase ( unittest.TestCase ): def __init__( self : Optional[Any] , A : Dict , A : Union[str, Any]=13 , A : Dict=7 , A : Dict=True , A : Tuple=True , A : Union[str, Any]=True , A : int=True , A : Optional[int]=99 , A : List[str]=32 , A : List[Any]=5 , A : int=4 , A : Any=37 , A : Optional[int]="gelu" , A : Optional[Any]=0.1 , A : Any=0.1 , A : Union[str, Any]=5_12 , A : int=16 , A : List[str]=2 , A : Union[str, Any]=0.0_2 , A : Union[str, Any]=4 , ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = seq_length _UpperCAmelCase = is_training _UpperCAmelCase = use_attention_mask _UpperCAmelCase = use_token_type_ids _UpperCAmelCase = use_labels _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = type_vocab_size _UpperCAmelCase = type_sequence_label_size _UpperCAmelCase = initializer_range _UpperCAmelCase = num_choices def _lowerCamelCase ( self : Optional[Any]) -> List[Any]: """simple docstring""" _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size) _UpperCAmelCase = None if self.use_attention_mask: _UpperCAmelCase = random_attention_mask([self.batch_size, self.seq_length]) _UpperCAmelCase = None if self.use_token_type_ids: _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size) _UpperCAmelCase = RoFormerConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , is_decoder=A , initializer_range=self.initializer_range , ) return config, input_ids, token_type_ids, attention_mask def _lowerCamelCase ( self : List[Any]) -> List[str]: """simple docstring""" _UpperCAmelCase = self.prepare_config_and_inputs() _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = config_and_inputs _UpperCAmelCase = {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': attention_mask} return config, inputs_dict @require_flax class __lowerCAmelCase ( A , unittest.TestCase ): UpperCamelCase = True UpperCamelCase = ( ( FlaxRoFormerModel, FlaxRoFormerForMaskedLM, FlaxRoFormerForSequenceClassification, FlaxRoFormerForTokenClassification, FlaxRoFormerForMultipleChoice, FlaxRoFormerForQuestionAnswering, ) if is_flax_available() else () ) def _lowerCamelCase ( self : Optional[int]) -> Any: """simple docstring""" _UpperCAmelCase = FlaxRoFormerModelTester(self) @slow def _lowerCamelCase ( self : List[Any]) -> Dict: """simple docstring""" for model_class_name in self.all_model_classes: _UpperCAmelCase = model_class_name.from_pretrained('junnyu/roformer_chinese_small' , from_pt=A) _UpperCAmelCase = model(np.ones((1, 1))) self.assertIsNotNone(A) @require_flax class __lowerCAmelCase ( unittest.TestCase ): @slow def _lowerCamelCase ( self : List[Any]) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = FlaxRoFormerForMaskedLM.from_pretrained('junnyu/roformer_chinese_base') _UpperCAmelCase = jnp.array([[0, 1, 2, 3, 4, 5]]) _UpperCAmelCase = model(A)[0] _UpperCAmelCase = 5_00_00 _UpperCAmelCase = (1, 6, vocab_size) self.assertEqual(output.shape , A) _UpperCAmelCase = jnp.array( [[[-0.1_2_0_5, -1.0_2_6_5, 0.2_9_2_2], [-1.5_1_3_4, 0.1_9_7_4, 0.1_5_1_9], [-5.0_1_3_5, -3.9_0_0_3, -0.8_4_0_4]]]) self.assertTrue(jnp.allclose(output[:, :3, :3] , A , atol=1E-4))
339
1
import argparse import os import torch from transformers import FlavaConfig, FlavaForPreTraining from transformers.models.flava.convert_dalle_to_flava_codebook import convert_dalle_checkpoint def A ( _UpperCAmelCase : List[Any] ) -> Optional[int]: '''simple docstring''' # encoder.embeddings are double copied in original FLAVA return sum(param.float().sum() if 'encoder.embeddings' not in key else 0 for key, param in state_dict.items() ) def A ( _UpperCAmelCase : Optional[int] , _UpperCAmelCase : Dict ) -> Dict: '''simple docstring''' _UpperCAmelCase = {} for key, value in state_dict.items(): if "text_encoder.embeddings" in key or "image_encoder.embeddings" in key: continue _UpperCAmelCase = key.replace('heads.cmd.mim_head.cls.predictions' , 'mmm_image_head' ) _UpperCAmelCase = key.replace('heads.cmd.mlm_head.cls.predictions' , 'mmm_text_head' ) _UpperCAmelCase = key.replace('heads.cmd.itm_head.cls' , 'itm_head' ) _UpperCAmelCase = key.replace('heads.cmd.itm_head.pooler' , 'itm_head.pooler' ) _UpperCAmelCase = key.replace('heads.cmd.clip_head.logit_scale' , 'flava.logit_scale' ) _UpperCAmelCase = key.replace('heads.fairseq_mlm.cls.predictions' , 'mlm_head' ) _UpperCAmelCase = key.replace('heads.imagenet.mim_head.cls.predictions' , 'mim_head' ) _UpperCAmelCase = key.replace('mm_text_projection' , 'flava.text_to_mm_projection' ) _UpperCAmelCase = key.replace('mm_image_projection' , 'flava.image_to_mm_projection' ) _UpperCAmelCase = key.replace('image_encoder.module' , 'flava.image_model' ) _UpperCAmelCase = key.replace('text_encoder.module' , 'flava.text_model' ) _UpperCAmelCase = key.replace('mm_encoder.module.encoder.cls_token' , 'flava.multimodal_model.cls_token' ) _UpperCAmelCase = key.replace('mm_encoder.module' , 'flava.multimodal_model' ) _UpperCAmelCase = key.replace('text_projection' , 'flava.text_projection' ) _UpperCAmelCase = key.replace('image_projection' , 'flava.image_projection' ) _UpperCAmelCase = value.float() for key, value in codebook_state_dict.items(): _UpperCAmelCase = value return upgrade @torch.no_grad() def A ( _UpperCAmelCase : str , _UpperCAmelCase : Dict , _UpperCAmelCase : Any , _UpperCAmelCase : int=None ) -> Tuple: '''simple docstring''' if config_path is not None: _UpperCAmelCase = FlavaConfig.from_pretrained(_UpperCAmelCase ) else: _UpperCAmelCase = FlavaConfig() _UpperCAmelCase = FlavaForPreTraining(_UpperCAmelCase ).eval() _UpperCAmelCase = convert_dalle_checkpoint(_UpperCAmelCase , _UpperCAmelCase , save_checkpoint=_UpperCAmelCase ) if os.path.exists(_UpperCAmelCase ): _UpperCAmelCase = torch.load(_UpperCAmelCase , map_location='cpu' ) else: _UpperCAmelCase = torch.hub.load_state_dict_from_url(_UpperCAmelCase , map_location='cpu' ) _UpperCAmelCase = upgrade_state_dict(_UpperCAmelCase , _UpperCAmelCase ) hf_model.load_state_dict(_UpperCAmelCase ) _UpperCAmelCase = hf_model.state_dict() _UpperCAmelCase = count_parameters(_UpperCAmelCase ) _UpperCAmelCase = count_parameters(_UpperCAmelCase ) + count_parameters(_UpperCAmelCase ) assert torch.allclose(_UpperCAmelCase , _UpperCAmelCase , atol=1E-3 ) hf_model.save_pretrained(_UpperCAmelCase ) if __name__ == "__main__": UpperCAmelCase__ = argparse.ArgumentParser() parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.") parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to flava checkpoint") parser.add_argument("--codebook_path", default=None, type=str, help="Path to flava codebook checkpoint") parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert") UpperCAmelCase__ = parser.parse_args() convert_flava_checkpoint(args.checkpoint_path, args.codebook_path, args.pytorch_dump_folder_path, args.config_path)
339
UpperCAmelCase__ = {} def A ( _UpperCAmelCase : int , _UpperCAmelCase : int , _UpperCAmelCase : int ) -> int: '''simple docstring''' # if we are absent twice, or late 3 consecutive days, # no further prize strings are possible if late == 3 or absent == 2: return 0 # if we have no days left, and have not failed any other rules, # we have a prize string if days == 0: return 1 # No easy solution, so now we need to do the recursive calculation # First, check if the combination is already in the cache, and # if yes, return the stored value from there since we already # know the number of possible prize strings from this point on _UpperCAmelCase = (days, absent, late) if key in cache: return cache[key] # now we calculate the three possible ways that can unfold from # this point on, depending on our attendance today # 1) if we are late (but not absent), the "absent" counter stays as # it is, but the "late" counter increases by one _UpperCAmelCase = _calculate(days - 1 , _UpperCAmelCase , late + 1 ) # 2) if we are absent, the "absent" counter increases by 1, and the # "late" counter resets to 0 _UpperCAmelCase = _calculate(days - 1 , absent + 1 , 0 ) # 3) if we are on time, this resets the "late" counter and keeps the # absent counter _UpperCAmelCase = _calculate(days - 1 , _UpperCAmelCase , 0 ) _UpperCAmelCase = state_late + state_absent + state_ontime _UpperCAmelCase = prizestrings return prizestrings def A ( _UpperCAmelCase : int = 30 ) -> int: '''simple docstring''' return _calculate(_UpperCAmelCase , absent=0 , late=0 ) if __name__ == "__main__": print(solution())
339
1
from __future__ import annotations def A ( _UpperCAmelCase : str , _UpperCAmelCase : list[str] | None = None ) -> list[list[str]]: '''simple docstring''' _UpperCAmelCase = word_bank or [] # create a table _UpperCAmelCase = len(_UpperCAmelCase ) + 1 _UpperCAmelCase = [] for _ in range(_UpperCAmelCase ): table.append([] ) # seed value _UpperCAmelCase = [[]] # because empty string has empty combination # iterate through the indices for i in range(_UpperCAmelCase ): # condition if table[i] != []: for word in word_bank: # slice condition if target[i : i + len(_UpperCAmelCase )] == word: _UpperCAmelCase = [ [word, *way] for way in table[i] ] # adds the word to every combination the current position holds # now,push that combination to the table[i+len(word)] table[i + len(_UpperCAmelCase )] += new_combinations # combinations are in reverse order so reverse for better output for combination in table[len(_UpperCAmelCase )]: combination.reverse() return table[len(_UpperCAmelCase )] if __name__ == "__main__": print(all_construct("jwajalapa", ["jwa", "j", "w", "a", "la", "lapa"])) print(all_construct("rajamati", ["s", "raj", "amat", "raja", "ma", "i", "t"])) print( all_construct( "hexagonosaurus", ["h", "ex", "hex", "ag", "ago", "ru", "auru", "rus", "go", "no", "o", "s"], ) )
339
import os import sys import unittest UpperCAmelCase__ = 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_dummies # noqa: E402 from check_dummies import create_dummy_files, create_dummy_object, find_backend, read_init # noqa: E402 # Align TRANSFORMERS_PATH in check_dummies with the current path UpperCAmelCase__ = os.path.join(git_repo_path, "src", "diffusers") class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Tuple) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = find_backend(' if not is_torch_available():') self.assertEqual(A , 'torch') # backend_with_underscore = find_backend(" if not is_tensorflow_text_available():") # self.assertEqual(backend_with_underscore, "tensorflow_text") _UpperCAmelCase = find_backend(' if not (is_torch_available() and is_transformers_available()):') self.assertEqual(A , 'torch_and_transformers') # double_backend_with_underscore = find_backend( # " if not (is_sentencepiece_available() and is_tensorflow_text_available()):" # ) # self.assertEqual(double_backend_with_underscore, "sentencepiece_and_tensorflow_text") _UpperCAmelCase = find_backend( ' if not (is_torch_available() and is_transformers_available() and is_onnx_available()):') self.assertEqual(A , 'torch_and_transformers_and_onnx') def _lowerCamelCase ( self : int) -> Dict: """simple docstring""" _UpperCAmelCase = read_init() # We don't assert on the exact list of keys to allow for smooth grow of backend-specific objects self.assertIn('torch' , A) self.assertIn('torch_and_transformers' , A) self.assertIn('flax_and_transformers' , A) self.assertIn('torch_and_transformers_and_onnx' , A) # Likewise, we can't assert on the exact content of a key self.assertIn('UNet2DModel' , objects['torch']) self.assertIn('FlaxUNet2DConditionModel' , objects['flax']) self.assertIn('StableDiffusionPipeline' , objects['torch_and_transformers']) self.assertIn('FlaxStableDiffusionPipeline' , objects['flax_and_transformers']) self.assertIn('LMSDiscreteScheduler' , objects['torch_and_scipy']) self.assertIn('OnnxStableDiffusionPipeline' , objects['torch_and_transformers_and_onnx']) def _lowerCamelCase ( self : Union[str, Any]) -> List[Any]: """simple docstring""" _UpperCAmelCase = create_dummy_object('CONSTANT' , '\'torch\'') self.assertEqual(A , '\nCONSTANT = None\n') _UpperCAmelCase = create_dummy_object('function' , '\'torch\'') self.assertEqual( A , '\ndef function(*args, **kwargs):\n requires_backends(function, \'torch\')\n') _UpperCAmelCase = '\nclass FakeClass(metaclass=DummyObject):\n _backends = \'torch\'\n\n def __init__(self, *args, **kwargs):\n requires_backends(self, \'torch\')\n\n @classmethod\n def from_config(cls, *args, **kwargs):\n requires_backends(cls, \'torch\')\n\n @classmethod\n def from_pretrained(cls, *args, **kwargs):\n requires_backends(cls, \'torch\')\n' _UpperCAmelCase = create_dummy_object('FakeClass' , '\'torch\'') self.assertEqual(A , A) def _lowerCamelCase ( self : Dict) -> int: """simple docstring""" _UpperCAmelCase = '# This file is autogenerated by the command `make fix-copies`, do not edit.\nfrom ..utils import DummyObject, requires_backends\n\n\nCONSTANT = None\n\n\ndef function(*args, **kwargs):\n requires_backends(function, ["torch"])\n\n\nclass FakeClass(metaclass=DummyObject):\n _backends = ["torch"]\n\n def __init__(self, *args, **kwargs):\n requires_backends(self, ["torch"])\n\n @classmethod\n def from_config(cls, *args, **kwargs):\n requires_backends(cls, ["torch"])\n\n @classmethod\n def from_pretrained(cls, *args, **kwargs):\n requires_backends(cls, ["torch"])\n' _UpperCAmelCase = create_dummy_files({'torch': ['CONSTANT', 'function', 'FakeClass']}) self.assertEqual(dummy_files['torch'] , A)
339
1
import gc import random import unittest import torch from diffusers import ( IFImgaImgPipeline, IFImgaImgSuperResolutionPipeline, IFInpaintingPipeline, IFInpaintingSuperResolutionPipeline, IFPipeline, IFSuperResolutionPipeline, ) from diffusers.models.attention_processor import AttnAddedKVProcessor from diffusers.utils.import_utils import is_xformers_available from diffusers.utils.testing_utils import floats_tensor, load_numpy, require_torch_gpu, skip_mps, slow, torch_device from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference from . import IFPipelineTesterMixin @skip_mps class __lowerCAmelCase ( A , A , unittest.TestCase ): UpperCamelCase = IFPipeline UpperCamelCase = TEXT_TO_IMAGE_PARAMS - {'''width''', '''height''', '''latents'''} UpperCamelCase = TEXT_TO_IMAGE_BATCH_PARAMS UpperCamelCase = PipelineTesterMixin.required_optional_params - {'''latents'''} def _lowerCamelCase ( self : Optional[int]) -> List[Any]: """simple docstring""" return self._get_dummy_components() def _lowerCamelCase ( self : Tuple , A : int , A : str=0) -> Optional[int]: """simple docstring""" if str(A).startswith('mps'): _UpperCAmelCase = torch.manual_seed(A) else: _UpperCAmelCase = torch.Generator(device=A).manual_seed(A) _UpperCAmelCase = { 'prompt': 'A painting of a squirrel eating a burger', 'generator': generator, 'num_inference_steps': 2, 'output_type': 'numpy', } return inputs def _lowerCamelCase ( self : Union[str, Any]) -> List[Any]: """simple docstring""" self._test_save_load_optional_components() @unittest.skipIf(torch_device != 'cuda' , reason='float16 requires CUDA') def _lowerCamelCase ( self : List[str]) -> str: """simple docstring""" super().test_save_load_floataa(expected_max_diff=1E-1) def _lowerCamelCase ( self : List[Any]) -> Optional[int]: """simple docstring""" self._test_attention_slicing_forward_pass(expected_max_diff=1E-2) def _lowerCamelCase ( self : Tuple) -> Union[str, Any]: """simple docstring""" self._test_save_load_local() def _lowerCamelCase ( self : List[str]) -> Optional[Any]: """simple docstring""" self._test_inference_batch_single_identical( expected_max_diff=1E-2 , ) @unittest.skipIf( torch_device != 'cuda' or not is_xformers_available() , reason='XFormers attention is only available with CUDA and `xformers` installed' , ) def _lowerCamelCase ( self : Optional[Any]) -> str: """simple docstring""" self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3) @slow @require_torch_gpu class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Optional[int]) -> Tuple: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def _lowerCamelCase ( self : int) -> int: """simple docstring""" _UpperCAmelCase = IFPipeline.from_pretrained('DeepFloyd/IF-I-XL-v1.0' , variant='fp16' , torch_dtype=torch.floataa) _UpperCAmelCase = IFSuperResolutionPipeline.from_pretrained( 'DeepFloyd/IF-II-L-v1.0' , variant='fp16' , torch_dtype=torch.floataa , text_encoder=A , tokenizer=A) # pre compute text embeddings and remove T5 to save memory pipe_a.text_encoder.to('cuda') _UpperCAmelCase , _UpperCAmelCase = pipe_a.encode_prompt('anime turtle' , device='cuda') del pipe_a.tokenizer del pipe_a.text_encoder gc.collect() _UpperCAmelCase = None _UpperCAmelCase = None pipe_a.enable_model_cpu_offload() pipe_a.enable_model_cpu_offload() pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()) pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()) self._test_if(A , A , A , A) pipe_a.remove_all_hooks() pipe_a.remove_all_hooks() # img2img _UpperCAmelCase = IFImgaImgPipeline(**pipe_a.components) _UpperCAmelCase = IFImgaImgSuperResolutionPipeline(**pipe_a.components) pipe_a.enable_model_cpu_offload() pipe_a.enable_model_cpu_offload() pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()) pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()) self._test_if_imgaimg(A , A , A , A) pipe_a.remove_all_hooks() pipe_a.remove_all_hooks() # inpainting _UpperCAmelCase = IFInpaintingPipeline(**pipe_a.components) _UpperCAmelCase = IFInpaintingSuperResolutionPipeline(**pipe_a.components) pipe_a.enable_model_cpu_offload() pipe_a.enable_model_cpu_offload() pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()) pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()) self._test_if_inpainting(A , A , A , A) def _lowerCamelCase ( self : List[str] , A : Tuple , A : Any , A : List[str] , A : List[Any]) -> Tuple: """simple docstring""" _start_torch_memory_measurement() _UpperCAmelCase = torch.Generator(device='cpu').manual_seed(0) _UpperCAmelCase = pipe_a( prompt_embeds=A , negative_prompt_embeds=A , num_inference_steps=2 , generator=A , output_type='np' , ) _UpperCAmelCase = output.images[0] assert image.shape == (64, 64, 3) _UpperCAmelCase = torch.cuda.max_memory_allocated() assert mem_bytes < 13 * 10**9 _UpperCAmelCase = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if.npy') assert_mean_pixel_difference(A , A) # pipeline 2 _start_torch_memory_measurement() _UpperCAmelCase = torch.Generator(device='cpu').manual_seed(0) _UpperCAmelCase = floats_tensor((1, 3, 64, 64) , rng=random.Random(0)).to(A) _UpperCAmelCase = pipe_a( prompt_embeds=A , negative_prompt_embeds=A , image=A , generator=A , num_inference_steps=2 , output_type='np' , ) _UpperCAmelCase = output.images[0] assert image.shape == (2_56, 2_56, 3) _UpperCAmelCase = torch.cuda.max_memory_allocated() assert mem_bytes < 4 * 10**9 _UpperCAmelCase = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_superresolution_stage_II.npy') assert_mean_pixel_difference(A , A) def _lowerCamelCase ( self : List[str] , A : List[Any] , A : int , A : Any , A : Tuple) -> str: """simple docstring""" _start_torch_memory_measurement() _UpperCAmelCase = floats_tensor((1, 3, 64, 64) , rng=random.Random(0)).to(A) _UpperCAmelCase = torch.Generator(device='cpu').manual_seed(0) _UpperCAmelCase = pipe_a( prompt_embeds=A , negative_prompt_embeds=A , image=A , num_inference_steps=2 , generator=A , output_type='np' , ) _UpperCAmelCase = output.images[0] assert image.shape == (64, 64, 3) _UpperCAmelCase = torch.cuda.max_memory_allocated() assert mem_bytes < 10 * 10**9 _UpperCAmelCase = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img.npy') assert_mean_pixel_difference(A , A) # pipeline 2 _start_torch_memory_measurement() _UpperCAmelCase = torch.Generator(device='cpu').manual_seed(0) _UpperCAmelCase = floats_tensor((1, 3, 2_56, 2_56) , rng=random.Random(0)).to(A) _UpperCAmelCase = floats_tensor((1, 3, 64, 64) , rng=random.Random(0)).to(A) _UpperCAmelCase = pipe_a( prompt_embeds=A , negative_prompt_embeds=A , image=A , original_image=A , generator=A , num_inference_steps=2 , output_type='np' , ) _UpperCAmelCase = output.images[0] assert image.shape == (2_56, 2_56, 3) _UpperCAmelCase = torch.cuda.max_memory_allocated() assert mem_bytes < 4 * 10**9 _UpperCAmelCase = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img_superresolution_stage_II.npy') assert_mean_pixel_difference(A , A) def _lowerCamelCase ( self : Dict , A : Tuple , A : int , A : List[str] , A : Tuple) -> str: """simple docstring""" _start_torch_memory_measurement() _UpperCAmelCase = floats_tensor((1, 3, 64, 64) , rng=random.Random(0)).to(A) _UpperCAmelCase = floats_tensor((1, 3, 64, 64) , rng=random.Random(1)).to(A) _UpperCAmelCase = torch.Generator(device='cpu').manual_seed(0) _UpperCAmelCase = pipe_a( prompt_embeds=A , negative_prompt_embeds=A , image=A , mask_image=A , num_inference_steps=2 , generator=A , output_type='np' , ) _UpperCAmelCase = output.images[0] assert image.shape == (64, 64, 3) _UpperCAmelCase = torch.cuda.max_memory_allocated() assert mem_bytes < 10 * 10**9 _UpperCAmelCase = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting.npy') assert_mean_pixel_difference(A , A) # pipeline 2 _start_torch_memory_measurement() _UpperCAmelCase = torch.Generator(device='cpu').manual_seed(0) _UpperCAmelCase = floats_tensor((1, 3, 64, 64) , rng=random.Random(0)).to(A) _UpperCAmelCase = floats_tensor((1, 3, 2_56, 2_56) , rng=random.Random(0)).to(A) _UpperCAmelCase = floats_tensor((1, 3, 2_56, 2_56) , rng=random.Random(1)).to(A) _UpperCAmelCase = pipe_a( prompt_embeds=A , negative_prompt_embeds=A , image=A , mask_image=A , original_image=A , generator=A , num_inference_steps=2 , output_type='np' , ) _UpperCAmelCase = output.images[0] assert image.shape == (2_56, 2_56, 3) _UpperCAmelCase = torch.cuda.max_memory_allocated() assert mem_bytes < 4 * 10**9 _UpperCAmelCase = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting_superresolution_stage_II.npy') assert_mean_pixel_difference(A , A) def A ( ) -> List[str]: '''simple docstring''' torch.cuda.empty_cache() torch.cuda.reset_max_memory_allocated() torch.cuda.reset_peak_memory_stats()
339
import logging import os import random import sys from dataclasses import dataclass, field from typing import Optional import datasets import numpy as np import pandas as pd from datasets import load_dataset import transformers from transformers import ( AutoConfig, BartForSequenceClassification, DataCollatorWithPadding, EvalPrediction, HfArgumentParser, TapexTokenizer, Trainer, TrainingArguments, default_data_collator, set_seed, ) from transformers.trainer_utils import get_last_checkpoint from transformers.utils import check_min_version from transformers.utils.versions import require_version # Will error if the minimal version of Transformers is not installed. Remove at your own risks. check_min_version("4.17.0.dev0") require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/text-classification/requirements.txt") UpperCAmelCase__ = logging.getLogger(__name__) @dataclass class __lowerCAmelCase : UpperCamelCase = field( default='''tab_fact''' , metadata={'''help''': '''The name of the dataset to use (via the datasets library).'''} ) UpperCamelCase = field( default='''tab_fact''' , metadata={'''help''': '''The configuration name of the dataset to use (via the datasets library).'''} , ) UpperCamelCase = field( default=1_0_2_4 , metadata={ '''help''': ( '''The maximum total input sequence length after tokenization. Sequences longer ''' '''than this will be truncated, sequences shorter will be padded.''' ) } , ) UpperCamelCase = field( default=A , metadata={'''help''': '''Overwrite the cached preprocessed datasets or not.'''} ) UpperCamelCase = field( default=A , 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.''' ) } , ) UpperCamelCase = field( default=A , metadata={ '''help''': ( '''For debugging purposes or quicker training, truncate the number of training examples to this ''' '''value if set.''' ) } , ) UpperCamelCase = field( default=A , metadata={ '''help''': ( '''For debugging purposes or quicker training, truncate the number of evaluation examples to this ''' '''value if set.''' ) } , ) UpperCamelCase = field( default=A , metadata={ '''help''': ( '''For debugging purposes or quicker training, truncate the number of prediction examples to this ''' '''value if set.''' ) } , ) UpperCamelCase = field( default=A , metadata={'''help''': '''A csv or a json file containing the training data.'''} ) UpperCamelCase = field( default=A , metadata={'''help''': '''A csv or a json file containing the validation data.'''} ) UpperCamelCase = field(default=A , metadata={'''help''': '''A csv or a json file containing the test data.'''} ) def _lowerCamelCase ( self : str) -> List[Any]: """simple docstring""" if self.dataset_name is not None: pass elif self.train_file is None or self.validation_file is None: raise ValueError('Need either a GLUE task, a training/validation file or a dataset name.') else: _UpperCAmelCase = self.train_file.split('.')[-1] assert train_extension in ["csv", "json"], "`train_file` should be a csv or a json file." _UpperCAmelCase = self.validation_file.split('.')[-1] assert ( validation_extension == train_extension ), "`validation_file` should have the same extension (csv or json) as `train_file`." @dataclass class __lowerCAmelCase : UpperCamelCase = field( default=A , metadata={'''help''': '''Path to pretrained model or model identifier from huggingface.co/models'''} ) UpperCamelCase = field( default=A , metadata={'''help''': '''Pretrained config name or path if not the same as model_name'''} ) UpperCamelCase = field( default=A , metadata={'''help''': '''Pretrained tokenizer name or path if not the same as model_name'''} ) UpperCamelCase = field( default=A , metadata={'''help''': '''Where do you want to store the pretrained models downloaded from huggingface.co'''} , ) UpperCamelCase = field( default=A , metadata={'''help''': '''Whether to use one of the fast tokenizer (backed by the tokenizers library) or not.'''} , ) UpperCamelCase = field( default='''main''' , metadata={'''help''': '''The specific model version to use (can be a branch name, tag name or commit id).'''} , ) UpperCamelCase = field( default=A , metadata={ '''help''': ( '''Will use the token generated when running `huggingface-cli login` (necessary to use this script ''' '''with private models).''' ) } , ) def A ( ) -> Optional[int]: '''simple docstring''' # See all possible arguments in src/transformers/training_args.py # or by passing the --help flag to this script. # We now keep distinct sets of args, for a cleaner separation of concerns. _UpperCAmelCase = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments) ) if len(sys.argv ) == 2 and sys.argv[1].endswith('.json' ): # If we pass only one argument to the script and it's the path to a json file, # let's parse it to get our arguments. _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1] ) ) else: _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = parser.parse_args_into_dataclasses() # Setup logging logging.basicConfig( format='%(asctime)s - %(levelname)s - %(name)s - %(message)s' , datefmt='%m/%d/%Y %H:%M:%S' , handlers=[logging.StreamHandler(sys.stdout )] , ) _UpperCAmelCase = training_args.get_process_log_level() logger.setLevel(_UpperCAmelCase ) datasets.utils.logging.set_verbosity(_UpperCAmelCase ) transformers.utils.logging.set_verbosity(_UpperCAmelCase ) transformers.utils.logging.enable_default_handler() transformers.utils.logging.enable_explicit_format() # Log on each process the small summary: logger.warning( F"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}" + F"distributed training: {bool(training_args.local_rank != -1 )}, 16-bits training: {training_args.fpaa}" ) logger.info(F"Training/evaluation parameters {training_args}" ) # Detecting last checkpoint. _UpperCAmelCase = None if os.path.isdir(training_args.output_dir ) and training_args.do_train and not training_args.overwrite_output_dir: _UpperCAmelCase = get_last_checkpoint(training_args.output_dir ) if last_checkpoint is None and len(os.listdir(training_args.output_dir ) ) > 0: raise ValueError( F"Output directory ({training_args.output_dir}) already exists and is not empty. " 'Use --overwrite_output_dir to overcome.' ) elif last_checkpoint is not None and training_args.resume_from_checkpoint is None: logger.info( F"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change " 'the `--output_dir` or add `--overwrite_output_dir` to train from scratch.' ) # Set seed before initializing model. set_seed(training_args.seed ) # Get the datasets: you can either provide your own CSV/JSON training and evaluation files (see below) # or specify a GLUE benchmark task (the dataset will be downloaded automatically from the datasets Hub). # # For JSON files, this script will use the `question` column for the input question and `table` column for the corresponding table. # # If the CSVs/JSONs contain only one non-label column, the script does single sentence classification on this # single column. You can easily tweak this behavior (see below) # # In distributed training, the load_dataset function guarantee that only one local process can concurrently # download the dataset. if data_args.dataset_name is not None: # Downloading and loading a dataset from the hub. _UpperCAmelCase = load_dataset( data_args.dataset_name , data_args.dataset_config_name , cache_dir=model_args.cache_dir ) else: # Loading a dataset from your local files. # CSV/JSON training and evaluation files are needed. _UpperCAmelCase = {'train': data_args.train_file, 'validation': data_args.validation_file} # Get the test dataset: you can provide your own CSV/JSON test file (see below) # when you use `do_predict` without specifying a GLUE benchmark task. if training_args.do_predict: if data_args.test_file is not None: _UpperCAmelCase = data_args.train_file.split('.' )[-1] _UpperCAmelCase = data_args.test_file.split('.' )[-1] assert ( test_extension == train_extension ), "`test_file` should have the same extension (csv or json) as `train_file`." _UpperCAmelCase = data_args.test_file else: raise ValueError('Need either a GLUE task or a test file for `do_predict`.' ) for key in data_files.keys(): logger.info(F"load a local file for {key}: {data_files[key]}" ) if data_args.train_file.endswith('.csv' ): # Loading a dataset from local csv files _UpperCAmelCase = load_dataset('csv' , data_files=_UpperCAmelCase , cache_dir=model_args.cache_dir ) else: # Loading a dataset from local json files _UpperCAmelCase = load_dataset('json' , data_files=_UpperCAmelCase , cache_dir=model_args.cache_dir ) # See more about loading any type of standard or custom dataset at # https://huggingface.co/docs/datasets/loading_datasets.html. # Labels _UpperCAmelCase = raw_datasets['train'].features['label'].names _UpperCAmelCase = len(_UpperCAmelCase ) # Load pretrained model and tokenizer # # In distributed training, the .from_pretrained methods guarantee that only one local process can concurrently # download model & vocab. _UpperCAmelCase = AutoConfig.from_pretrained( model_args.config_name if model_args.config_name else model_args.model_name_or_path , num_labels=_UpperCAmelCase , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , ) # load tapex tokenizer _UpperCAmelCase = TapexTokenizer.from_pretrained( model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path , cache_dir=model_args.cache_dir , use_fast=model_args.use_fast_tokenizer , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , add_prefix_space=_UpperCAmelCase , ) _UpperCAmelCase = BartForSequenceClassification.from_pretrained( model_args.model_name_or_path , from_tf=bool('.ckpt' in model_args.model_name_or_path ) , config=_UpperCAmelCase , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , ) # Padding strategy if data_args.pad_to_max_length: _UpperCAmelCase = 'max_length' else: # We will pad later, dynamically at batch creation, to the max sequence length in each batch _UpperCAmelCase = False # Some models have set the order of the labels to use, so let's make sure we do use it. _UpperCAmelCase = {'Refused': 0, 'Entailed': 1} _UpperCAmelCase = {0: 'Refused', 1: 'Entailed'} if data_args.max_seq_length > tokenizer.model_max_length: logger.warning( F"The max_seq_length passed ({data_args.max_seq_length}) is larger than the maximum length for the" F"model ({tokenizer.model_max_length}). Using max_seq_length={tokenizer.model_max_length}." ) _UpperCAmelCase = min(data_args.max_seq_length , tokenizer.model_max_length ) def preprocess_tabfact_function(_UpperCAmelCase : Union[str, Any] ): # Tokenize the texts def _convert_table_text_to_pandas(_UpperCAmelCase : Dict ): _UpperCAmelCase = [_table_row.split('#' ) for _table_row in _table_text.strip('\n' ).split('\n' )] _UpperCAmelCase = pd.DataFrame.from_records(_table_content[1:] , columns=_table_content[0] ) return _table_pd _UpperCAmelCase = examples['statement'] _UpperCAmelCase = list(map(_convert_table_text_to_pandas , examples['table_text'] ) ) _UpperCAmelCase = tokenizer(_UpperCAmelCase , _UpperCAmelCase , padding=_UpperCAmelCase , max_length=_UpperCAmelCase , truncation=_UpperCAmelCase ) _UpperCAmelCase = examples['label'] return result with training_args.main_process_first(desc='dataset map pre-processing' ): _UpperCAmelCase = raw_datasets.map( _UpperCAmelCase , batched=_UpperCAmelCase , load_from_cache_file=not data_args.overwrite_cache , desc='Running tokenizer on dataset' , ) if training_args.do_train: if "train" not in raw_datasets: raise ValueError('--do_train requires a train dataset' ) _UpperCAmelCase = raw_datasets['train'] if data_args.max_train_samples is not None: _UpperCAmelCase = train_dataset.select(range(data_args.max_train_samples ) ) if training_args.do_eval: if "validation" not in raw_datasets and "validation_matched" not in raw_datasets: raise ValueError('--do_eval requires a validation dataset' ) _UpperCAmelCase = raw_datasets['validation'] if data_args.max_eval_samples is not None: _UpperCAmelCase = eval_dataset.select(range(data_args.max_eval_samples ) ) if training_args.do_predict or data_args.test_file is not None: if "test" not in raw_datasets and "test_matched" not in raw_datasets: raise ValueError('--do_predict requires a test dataset' ) _UpperCAmelCase = raw_datasets['test'] if data_args.max_predict_samples is not None: _UpperCAmelCase = predict_dataset.select(range(data_args.max_predict_samples ) ) # Log a few random samples from the training set: if training_args.do_train: for index in random.sample(range(len(_UpperCAmelCase ) ) , 3 ): logger.info(F"Sample {index} of the training set: {train_dataset[index]}." ) # You can define your custom compute_metrics function. It takes an `EvalPrediction` object (a namedtuple with a # predictions and label_ids field) and has to return a dictionary string to float. def compute_metrics(_UpperCAmelCase : EvalPrediction ): _UpperCAmelCase = p.predictions[0] if isinstance(p.predictions , _UpperCAmelCase ) else p.predictions _UpperCAmelCase = np.argmax(_UpperCAmelCase , axis=1 ) return {"accuracy": (preds == p.label_ids).astype(np.floataa ).mean().item()} # Data collator will default to DataCollatorWithPadding, so we change it if we already did the padding. if data_args.pad_to_max_length: _UpperCAmelCase = default_data_collator elif training_args.fpaa: _UpperCAmelCase = DataCollatorWithPadding(_UpperCAmelCase , pad_to_multiple_of=8 ) else: _UpperCAmelCase = None # Initialize our Trainer _UpperCAmelCase = Trainer( model=_UpperCAmelCase , args=_UpperCAmelCase , train_dataset=train_dataset if training_args.do_train else None , eval_dataset=eval_dataset if training_args.do_eval else None , compute_metrics=_UpperCAmelCase , tokenizer=_UpperCAmelCase , data_collator=_UpperCAmelCase , ) # Training if training_args.do_train: _UpperCAmelCase = None if training_args.resume_from_checkpoint is not None: _UpperCAmelCase = training_args.resume_from_checkpoint elif last_checkpoint is not None: _UpperCAmelCase = last_checkpoint _UpperCAmelCase = trainer.train(resume_from_checkpoint=_UpperCAmelCase ) _UpperCAmelCase = train_result.metrics _UpperCAmelCase = ( data_args.max_train_samples if data_args.max_train_samples is not None else len(_UpperCAmelCase ) ) _UpperCAmelCase = min(_UpperCAmelCase , len(_UpperCAmelCase ) ) trainer.save_model() # Saves the tokenizer too for easy upload trainer.log_metrics('train' , _UpperCAmelCase ) trainer.save_metrics('train' , _UpperCAmelCase ) trainer.save_state() # Evaluation if training_args.do_eval: logger.info('*** Evaluate ***' ) _UpperCAmelCase = trainer.evaluate(eval_dataset=_UpperCAmelCase ) _UpperCAmelCase = data_args.max_eval_samples if data_args.max_eval_samples is not None else len(_UpperCAmelCase ) _UpperCAmelCase = min(_UpperCAmelCase , len(_UpperCAmelCase ) ) trainer.log_metrics('eval' , _UpperCAmelCase ) trainer.save_metrics('eval' , _UpperCAmelCase ) if training_args.do_predict: logger.info('*** Predict ***' ) # Removing the `label` columns because it contains -1 and Trainer won't like that. _UpperCAmelCase = predict_dataset.remove_columns('label' ) _UpperCAmelCase = trainer.predict(_UpperCAmelCase , metric_key_prefix='predict' ).predictions _UpperCAmelCase = np.argmax(_UpperCAmelCase , axis=1 ) _UpperCAmelCase = os.path.join(training_args.output_dir , 'predict_results_tabfact.txt' ) if trainer.is_world_process_zero(): with open(_UpperCAmelCase , 'w' ) as writer: logger.info('***** Predict Results *****' ) writer.write('index\tprediction\n' ) for index, item in enumerate(_UpperCAmelCase ): _UpperCAmelCase = label_list[item] writer.write(F"{index}\t{item}\n" ) _UpperCAmelCase = {'finetuned_from': model_args.model_name_or_path, 'tasks': 'text-classification'} if training_args.push_to_hub: trainer.push_to_hub(**_UpperCAmelCase ) else: trainer.create_model_card(**_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[Any] ) -> Optional[Any]: '''simple docstring''' # For xla_spawn (TPUs) main() if __name__ == "__main__": main()
339
1
from dataclasses import dataclass, field from typing import ClassVar, Dict from ..features import Features, Sequence, Value from .base import TaskTemplate @dataclass(frozen=A ) class __lowerCAmelCase ( A ): # `task` is not a ClassVar since we want it to be part of the `asdict` output for JSON serialization UpperCamelCase = field(default='''question-answering-extractive''' , metadata={'''include_in_asdict_even_if_is_default''': True} ) UpperCamelCase = Features({'''question''': Value('''string''' ), '''context''': Value('''string''' )} ) UpperCamelCase = Features( { '''answers''': Sequence( { '''text''': Value('''string''' ), '''answer_start''': Value('''int32''' ), } ) } ) UpperCamelCase = "question" UpperCamelCase = "context" UpperCamelCase = "answers" @property def _lowerCamelCase ( self : Dict) -> Dict[str, str]: """simple docstring""" return {self.question_column: "question", self.context_column: "context", self.answers_column: "answers"}
339
# This code is adapted from OpenAI's release # https://github.com/openai/human-eval/blob/master/human_eval/execution.py import contextlib import faulthandler import io import multiprocessing import os import platform import signal import tempfile def A ( _UpperCAmelCase : Union[str, Any] , _UpperCAmelCase : Dict , _UpperCAmelCase : Dict , _UpperCAmelCase : Dict ) -> Any: '''simple docstring''' _UpperCAmelCase = multiprocessing.Manager() _UpperCAmelCase = manager.list() _UpperCAmelCase = multiprocessing.Process(target=_UpperCAmelCase , args=(check_program, result, timeout) ) p.start() p.join(timeout=timeout + 1 ) if p.is_alive(): p.kill() if not result: result.append('timed out' ) return { "task_id": task_id, "passed": result[0] == "passed", "result": result[0], "completion_id": completion_id, } def A ( _UpperCAmelCase : str , _UpperCAmelCase : List[str] , _UpperCAmelCase : Dict ) -> Optional[int]: '''simple docstring''' with create_tempdir(): # These system calls are needed when cleaning up tempdir. import os import shutil _UpperCAmelCase = shutil.rmtree _UpperCAmelCase = os.rmdir _UpperCAmelCase = os.chdir # Disable functionalities that can make destructive changes to the test. reliability_guard() # Run program. try: _UpperCAmelCase = {} with swallow_io(): with time_limit(_UpperCAmelCase ): exec(_UpperCAmelCase , _UpperCAmelCase ) result.append('passed' ) except TimeoutException: result.append('timed out' ) except BaseException as e: result.append(F"failed: {e}" ) # Needed for cleaning up. _UpperCAmelCase = rmtree _UpperCAmelCase = rmdir _UpperCAmelCase = chdir @contextlib.contextmanager def A ( _UpperCAmelCase : Union[str, Any] ) -> Any: '''simple docstring''' def signal_handler(_UpperCAmelCase : List[Any] , _UpperCAmelCase : Dict ): raise TimeoutException('Timed out!' ) signal.setitimer(signal.ITIMER_REAL , _UpperCAmelCase ) signal.signal(signal.SIGALRM , _UpperCAmelCase ) try: yield finally: signal.setitimer(signal.ITIMER_REAL , 0 ) @contextlib.contextmanager def A ( ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = WriteOnlyStringIO() with contextlib.redirect_stdout(_UpperCAmelCase ): with contextlib.redirect_stderr(_UpperCAmelCase ): with redirect_stdin(_UpperCAmelCase ): yield @contextlib.contextmanager def A ( ) -> Any: '''simple docstring''' with tempfile.TemporaryDirectory() as dirname: with chdir(_UpperCAmelCase ): yield dirname class __lowerCAmelCase ( A ): pass class __lowerCAmelCase ( io.StringIO ): def _lowerCamelCase ( self : Tuple , *A : str , **A : Any) -> Any: """simple docstring""" raise OSError def _lowerCamelCase ( self : List[str] , *A : Optional[Any] , **A : Optional[Any]) -> Optional[int]: """simple docstring""" raise OSError def _lowerCamelCase ( self : str , *A : List[str] , **A : List[Any]) -> Union[str, Any]: """simple docstring""" raise OSError def _lowerCamelCase ( self : Union[str, Any] , *A : Optional[Any] , **A : List[str]) -> Optional[int]: """simple docstring""" return False class __lowerCAmelCase ( contextlib._RedirectStream ): # type: ignore UpperCamelCase = '''stdin''' @contextlib.contextmanager def A ( _UpperCAmelCase : List[Any] ) -> Dict: '''simple docstring''' if root == ".": yield return _UpperCAmelCase = os.getcwd() os.chdir(_UpperCAmelCase ) try: yield except BaseException as exc: raise exc finally: os.chdir(_UpperCAmelCase ) def A ( _UpperCAmelCase : List[str]=None ) -> Any: '''simple docstring''' if maximum_memory_bytes is not None: import resource resource.setrlimit(resource.RLIMIT_AS , (maximum_memory_bytes, maximum_memory_bytes) ) resource.setrlimit(resource.RLIMIT_DATA , (maximum_memory_bytes, maximum_memory_bytes) ) if not platform.uname().system == "Darwin": resource.setrlimit(resource.RLIMIT_STACK , (maximum_memory_bytes, maximum_memory_bytes) ) faulthandler.disable() import builtins _UpperCAmelCase = None _UpperCAmelCase = None import os _UpperCAmelCase = '1' _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None import shutil _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None import subprocess _UpperCAmelCase = None # type: ignore _UpperCAmelCase = None import sys _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None
339
1
from itertools import product from cva import COLOR_BGR2GRAY, cvtColor, imread, imshow, waitKey from numpy import dot, exp, mgrid, pi, ravel, square, uinta, zeros def A ( _UpperCAmelCase : Dict , _UpperCAmelCase : int ) -> int: '''simple docstring''' _UpperCAmelCase = k_size // 2 _UpperCAmelCase , _UpperCAmelCase = mgrid[0 - center : k_size - center, 0 - center : k_size - center] _UpperCAmelCase = 1 / (2 * pi * sigma) * exp(-(square(_UpperCAmelCase ) + square(_UpperCAmelCase )) / (2 * square(_UpperCAmelCase )) ) return g def A ( _UpperCAmelCase : Optional[int] , _UpperCAmelCase : Tuple , _UpperCAmelCase : Any ) -> List[str]: '''simple docstring''' _UpperCAmelCase , _UpperCAmelCase = image.shape[0], image.shape[1] # dst image height and width _UpperCAmelCase = height - k_size + 1 _UpperCAmelCase = width - k_size + 1 # im2col, turn the k_size*k_size pixels into a row and np.vstack all rows _UpperCAmelCase = zeros((dst_height * dst_width, k_size * k_size) ) _UpperCAmelCase = 0 for i, j in product(range(_UpperCAmelCase ) , range(_UpperCAmelCase ) ): _UpperCAmelCase = ravel(image[i : i + k_size, j : j + k_size] ) _UpperCAmelCase = window row += 1 # turn the kernel into shape(k*k, 1) _UpperCAmelCase = gen_gaussian_kernel(_UpperCAmelCase , _UpperCAmelCase ) _UpperCAmelCase = ravel(_UpperCAmelCase ) # reshape and get the dst image _UpperCAmelCase = dot(_UpperCAmelCase , _UpperCAmelCase ).reshape(_UpperCAmelCase , _UpperCAmelCase ).astype(_UpperCAmelCase ) return dst if __name__ == "__main__": # read original image UpperCAmelCase__ = imread(r"../image_data/lena.jpg") # turn image in gray scale value UpperCAmelCase__ = cvtColor(img, COLOR_BGR2GRAY) # get values with two different mask size UpperCAmelCase__ = gaussian_filter(gray, 3, sigma=1) UpperCAmelCase__ = gaussian_filter(gray, 5, sigma=0.8) # show result images imshow("gaussian filter with 3x3 mask", gaussianaxa) imshow("gaussian filter with 5x5 mask", gaussianaxa) waitKey()
339
import asyncio import os import shutil import subprocess import sys import tempfile import unittest from distutils.util import strtobool from functools import partial from pathlib import Path from typing import List, Union from unittest import mock import torch from ..state import AcceleratorState, PartialState from ..utils import ( gather, is_bnb_available, is_comet_ml_available, is_datasets_available, is_deepspeed_available, is_mps_available, is_safetensors_available, is_tensorboard_available, is_torch_version, is_tpu_available, is_transformers_available, is_wandb_available, is_xpu_available, ) def A ( _UpperCAmelCase : Tuple , _UpperCAmelCase : Union[str, Any]=False ) -> str: '''simple docstring''' try: _UpperCAmelCase = os.environ[key] except KeyError: # KEY isn't set, default to `default`. _UpperCAmelCase = default else: # KEY is set, convert it to True or False. try: _UpperCAmelCase = strtobool(_UpperCAmelCase ) except ValueError: # More values are supported, but let's keep the message simple. raise ValueError(F"If set, {key} must be yes or no." ) return _value UpperCAmelCase__ = parse_flag_from_env("RUN_SLOW", default=False) def A ( _UpperCAmelCase : List[str] ) -> List[str]: '''simple docstring''' return unittest.skip('Test was skipped' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Dict ) -> str: '''simple docstring''' return unittest.skipUnless(_run_slow_tests , 'test is slow' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Any ) -> str: '''simple docstring''' return unittest.skipUnless(not torch.cuda.is_available() , 'test requires only a CPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Dict ) -> Dict: '''simple docstring''' return unittest.skipUnless(torch.cuda.is_available() , 'test requires a GPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[Any] ) -> List[Any]: '''simple docstring''' return unittest.skipUnless(is_xpu_available() , 'test requires a XPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[int] ) -> List[str]: '''simple docstring''' return unittest.skipUnless(is_mps_available() , 'test requires a `mps` backend support in `torch`' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Union[str, Any] ) -> List[Any]: '''simple docstring''' return unittest.skipUnless( is_transformers_available() and is_datasets_available() , 'test requires the Hugging Face suite' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : str ) -> str: '''simple docstring''' return unittest.skipUnless(is_bnb_available() , 'test requires the bitsandbytes library' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Union[str, Any] ) -> List[Any]: '''simple docstring''' return unittest.skipUnless(is_tpu_available() , 'test requires TPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[Any] ) -> str: '''simple docstring''' return unittest.skipUnless(torch.cuda.device_count() == 1 , 'test requires a GPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Tuple ) -> int: '''simple docstring''' return unittest.skipUnless(torch.xpu.device_count() == 1 , 'test requires a XPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Any ) -> Optional[int]: '''simple docstring''' return unittest.skipUnless(torch.cuda.device_count() > 1 , 'test requires multiple GPUs' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Tuple ) -> Any: '''simple docstring''' return unittest.skipUnless(torch.xpu.device_count() > 1 , 'test requires multiple XPUs' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Any ) -> Optional[int]: '''simple docstring''' return unittest.skipUnless(is_safetensors_available() , 'test requires safetensors' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : List[Any] ) -> Dict: '''simple docstring''' return unittest.skipUnless(is_deepspeed_available() , 'test requires DeepSpeed' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[int] ) -> str: '''simple docstring''' return unittest.skipUnless(is_torch_version('>=' , '1.12.0' ) , 'test requires torch version >= 1.12.0' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Any=None , _UpperCAmelCase : List[Any]=None ) -> Dict: '''simple docstring''' if test_case is None: return partial(_UpperCAmelCase , version=_UpperCAmelCase ) return unittest.skipUnless(is_torch_version('>=' , _UpperCAmelCase ) , F"test requires torch version >= {version}" )(_UpperCAmelCase ) def A ( _UpperCAmelCase : List[str] ) -> int: '''simple docstring''' return unittest.skipUnless(is_tensorboard_available() , 'test requires Tensorboard' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Union[str, Any] ) -> Union[str, Any]: '''simple docstring''' return unittest.skipUnless(is_wandb_available() , 'test requires wandb' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : List[str] ) -> Optional[int]: '''simple docstring''' return unittest.skipUnless(is_comet_ml_available() , 'test requires comet_ml' )(_UpperCAmelCase ) UpperCAmelCase__ = ( any([is_wandb_available(), is_tensorboard_available()]) and not is_comet_ml_available() ) def A ( _UpperCAmelCase : List[str] ) -> Any: '''simple docstring''' return unittest.skipUnless( _atleast_one_tracker_available , 'test requires at least one tracker to be available and for `comet_ml` to not be installed' , )(_UpperCAmelCase ) class __lowerCAmelCase ( unittest.TestCase ): UpperCamelCase = True @classmethod def _lowerCamelCase ( cls : List[Any]) -> Tuple: """simple docstring""" _UpperCAmelCase = tempfile.mkdtemp() @classmethod def _lowerCamelCase ( cls : Union[str, Any]) -> str: """simple docstring""" if os.path.exists(cls.tmpdir): shutil.rmtree(cls.tmpdir) def _lowerCamelCase ( self : List[str]) -> List[Any]: """simple docstring""" if self.clear_on_setup: for path in Path(self.tmpdir).glob('**/*'): if path.is_file(): path.unlink() elif path.is_dir(): shutil.rmtree(A) class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Dict) -> Tuple: """simple docstring""" super().tearDown() # Reset the state of the AcceleratorState singleton. AcceleratorState._reset_state() PartialState._reset_state() class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Optional[int] , A : Union[mock.Mock, List[mock.Mock]]) -> Tuple: """simple docstring""" _UpperCAmelCase = mocks if isinstance(A , (tuple, list)) else [mocks] for m in self.mocks: m.start() self.addCleanup(m.stop) def A ( _UpperCAmelCase : List[Any] ) -> int: '''simple docstring''' _UpperCAmelCase = AcceleratorState() _UpperCAmelCase = tensor[None].clone().to(state.device ) _UpperCAmelCase = gather(_UpperCAmelCase ).cpu() _UpperCAmelCase = tensor[0].cpu() for i in range(tensors.shape[0] ): if not torch.equal(tensors[i] , _UpperCAmelCase ): return False return True class __lowerCAmelCase : def __init__( self : Optional[Any] , A : Union[str, Any] , A : Optional[int] , A : str) -> Optional[int]: """simple docstring""" _UpperCAmelCase = returncode _UpperCAmelCase = stdout _UpperCAmelCase = stderr async def A ( _UpperCAmelCase : str , _UpperCAmelCase : Optional[int] ) -> Optional[Any]: '''simple docstring''' while True: _UpperCAmelCase = await stream.readline() if line: callback(_UpperCAmelCase ) else: break async def A ( _UpperCAmelCase : Optional[int] , _UpperCAmelCase : List[str]=None , _UpperCAmelCase : str=None , _UpperCAmelCase : str=None , _UpperCAmelCase : Dict=False , _UpperCAmelCase : Union[str, Any]=False ) -> _RunOutput: '''simple docstring''' if echo: print('\nRunning: ' , ' '.join(_UpperCAmelCase ) ) _UpperCAmelCase = await asyncio.create_subprocess_exec( cmd[0] , *cmd[1:] , stdin=_UpperCAmelCase , stdout=asyncio.subprocess.PIPE , stderr=asyncio.subprocess.PIPE , env=_UpperCAmelCase , ) # note: there is a warning for a possible deadlock when using `wait` with huge amounts of data in the pipe # https://docs.python.org/3/library/asyncio-subprocess.html#asyncio.asyncio.subprocess.Process.wait # # If it starts hanging, will need to switch to the following code. The problem is that no data # will be seen until it's done and if it hangs for example there will be no debug info. # out, err = await p.communicate() # return _RunOutput(p.returncode, out, err) _UpperCAmelCase = [] _UpperCAmelCase = [] def tee(_UpperCAmelCase : Union[str, Any] , _UpperCAmelCase : List[Any] , _UpperCAmelCase : str , _UpperCAmelCase : str="" ): _UpperCAmelCase = line.decode('utf-8' ).rstrip() sink.append(_UpperCAmelCase ) if not quiet: print(_UpperCAmelCase , _UpperCAmelCase , file=_UpperCAmelCase ) # XXX: the timeout doesn't seem to make any difference here await asyncio.wait( [ asyncio.create_task(_read_stream(p.stdout , lambda _UpperCAmelCase : tee(_UpperCAmelCase , _UpperCAmelCase , sys.stdout , label='stdout:' ) ) ), asyncio.create_task(_read_stream(p.stderr , lambda _UpperCAmelCase : tee(_UpperCAmelCase , _UpperCAmelCase , sys.stderr , label='stderr:' ) ) ), ] , timeout=_UpperCAmelCase , ) return _RunOutput(await p.wait() , _UpperCAmelCase , _UpperCAmelCase ) def A ( _UpperCAmelCase : str , _UpperCAmelCase : Dict=None , _UpperCAmelCase : str=None , _UpperCAmelCase : str=180 , _UpperCAmelCase : List[Any]=False , _UpperCAmelCase : List[Any]=True ) -> _RunOutput: '''simple docstring''' _UpperCAmelCase = asyncio.get_event_loop() _UpperCAmelCase = loop.run_until_complete( _stream_subprocess(_UpperCAmelCase , env=_UpperCAmelCase , stdin=_UpperCAmelCase , timeout=_UpperCAmelCase , quiet=_UpperCAmelCase , echo=_UpperCAmelCase ) ) _UpperCAmelCase = ' '.join(_UpperCAmelCase ) if result.returncode > 0: _UpperCAmelCase = '\n'.join(result.stderr ) raise RuntimeError( F"'{cmd_str}' failed with returncode {result.returncode}\n\n" F"The combined stderr from workers follows:\n{stderr}" ) return result class __lowerCAmelCase ( A ): pass def A ( _UpperCAmelCase : List[str] , _UpperCAmelCase : str=False ) -> Tuple: '''simple docstring''' try: _UpperCAmelCase = subprocess.check_output(_UpperCAmelCase , stderr=subprocess.STDOUT ) if return_stdout: if hasattr(_UpperCAmelCase , 'decode' ): _UpperCAmelCase = output.decode('utf-8' ) return output except subprocess.CalledProcessError as e: raise SubprocessCallException( F"Command `{' '.join(_UpperCAmelCase )}` failed with the following error:\n\n{e.output.decode()}" ) from e
339
1
from typing import Tuple, Union from ...modeling_outputs import BackboneOutput from ...modeling_utils import PreTrainedModel from ...utils import is_timm_available, is_torch_available, requires_backends from ...utils.backbone_utils import BackboneMixin from .configuration_timm_backbone import TimmBackboneConfig if is_timm_available(): import timm if is_torch_available(): from torch import Tensor class __lowerCAmelCase ( A , A ): UpperCamelCase = '''pixel_values''' UpperCamelCase = False UpperCamelCase = TimmBackboneConfig def __init__( self : Any , A : Any , **A : Optional[int]) -> int: """simple docstring""" requires_backends(self , 'timm') super().__init__(A) _UpperCAmelCase = config if config.backbone is None: raise ValueError('backbone is not set in the config. Please set it to a timm model name.') if config.backbone not in timm.list_models(): raise ValueError(F"backbone {config.backbone} is not supported by timm.") if hasattr(A , 'out_features') and config.out_features is not None: raise ValueError('out_features is not supported by TimmBackbone. Please use out_indices instead.') _UpperCAmelCase = getattr(A , 'use_pretrained_backbone' , A) if pretrained is None: raise ValueError('use_pretrained_backbone is not set in the config. Please set it to True or False.') # We just take the final layer by default. This matches the default for the transformers models. _UpperCAmelCase = config.out_indices if getattr(A , 'out_indices' , A) is not None else (-1,) _UpperCAmelCase = timm.create_model( config.backbone , pretrained=A , features_only=config.features_only , in_chans=config.num_channels , out_indices=A , **A , ) # These are used to control the output of the model when called. If output_hidden_states is True, then # return_layers is modified to include all layers. _UpperCAmelCase = self._backbone.return_layers _UpperCAmelCase = {layer['module']: str(A) for i, layer in enumerate(self._backbone.feature_info.info)} super()._init_backbone(A) @classmethod def _lowerCamelCase ( cls : int , A : Tuple , *A : str , **A : Union[str, Any]) -> int: """simple docstring""" requires_backends(cls , ['vision', 'timm']) from ...models.timm_backbone import TimmBackboneConfig _UpperCAmelCase = kwargs.pop('config' , TimmBackboneConfig()) _UpperCAmelCase = kwargs.pop('use_timm_backbone' , A) if not use_timm: raise ValueError('use_timm_backbone must be True for timm backbones') _UpperCAmelCase = kwargs.pop('num_channels' , config.num_channels) _UpperCAmelCase = kwargs.pop('features_only' , config.features_only) _UpperCAmelCase = kwargs.pop('use_pretrained_backbone' , config.use_pretrained_backbone) _UpperCAmelCase = kwargs.pop('out_indices' , config.out_indices) _UpperCAmelCase = TimmBackboneConfig( backbone=A , num_channels=A , features_only=A , use_pretrained_backbone=A , out_indices=A , ) return super()._from_config(A , **A) def _lowerCamelCase ( self : Optional[Any] , A : Optional[Any]) -> List[str]: """simple docstring""" pass def _lowerCamelCase ( self : Tuple , A : int , A : List[str]=None , A : List[str]=None , A : Any=None , **A : int) -> Union[BackboneOutput, Tuple[Tensor, ...]]: """simple docstring""" _UpperCAmelCase = return_dict if return_dict is not None else self.config.use_return_dict _UpperCAmelCase = ( output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states ) _UpperCAmelCase = output_attentions if output_attentions is not None else self.config.output_attentions if output_attentions: raise ValueError('Cannot output attentions for timm backbones at the moment') if output_hidden_states: # We modify the return layers to include all the stages of the backbone _UpperCAmelCase = self._all_layers _UpperCAmelCase = self._backbone(A , **A) _UpperCAmelCase = self._return_layers _UpperCAmelCase = tuple(hidden_states[i] for i in self.out_indices) else: _UpperCAmelCase = self._backbone(A , **A) _UpperCAmelCase = None _UpperCAmelCase = tuple(A) _UpperCAmelCase = tuple(A) if hidden_states is not None else None if not return_dict: _UpperCAmelCase = (feature_maps,) if output_hidden_states: _UpperCAmelCase = output + (hidden_states,) return output return BackboneOutput(feature_maps=A , hidden_states=A , attentions=A)
339
from __future__ import annotations UpperCAmelCase__ = list[list[int]] # assigning initial values to the grid UpperCAmelCase__ = [ [3, 0, 6, 5, 0, 8, 4, 0, 0], [5, 2, 0, 0, 0, 0, 0, 0, 0], [0, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] # a grid with no solution UpperCAmelCase__ = [ [5, 0, 6, 5, 0, 8, 4, 0, 3], [5, 2, 0, 0, 0, 0, 0, 0, 2], [1, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] def A ( _UpperCAmelCase : Matrix , _UpperCAmelCase : int , _UpperCAmelCase : int , _UpperCAmelCase : int ) -> bool: '''simple docstring''' for i in range(9 ): if grid[row][i] == n or grid[i][column] == n: return False for i in range(3 ): for j in range(3 ): if grid[(row - row % 3) + i][(column - column % 3) + j] == n: return False return True def A ( _UpperCAmelCase : Matrix ) -> tuple[int, int] | None: '''simple docstring''' for i in range(9 ): for j in range(9 ): if grid[i][j] == 0: return i, j return None def A ( _UpperCAmelCase : Matrix ) -> Matrix | None: '''simple docstring''' if location := find_empty_location(_UpperCAmelCase ): _UpperCAmelCase , _UpperCAmelCase = location else: # If the location is ``None``, then the grid is solved. return grid for digit in range(1 , 10 ): if is_safe(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ): _UpperCAmelCase = digit if sudoku(_UpperCAmelCase ) is not None: return grid _UpperCAmelCase = 0 return None def A ( _UpperCAmelCase : Matrix ) -> None: '''simple docstring''' for row in grid: for cell in row: print(_UpperCAmelCase , end=' ' ) print() if __name__ == "__main__": # make a copy of grid so that you can compare with the unmodified grid for example_grid in (initial_grid, no_solution): print("\nExample grid:\n" + "=" * 20) print_solution(example_grid) print("\nExample grid solution:") UpperCAmelCase__ = sudoku(example_grid) if solution is not None: print_solution(solution) else: print("Cannot find a solution.")
339
1
# Copyright (c) 2021-, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. #################################################################################################### # # Note: If when running this conversion script you're getting an exception: # ModuleNotFoundError: No module named 'megatron.model.enums' # you need to tell python where to find the clone of Megatron-LM, e.g.: # # cd /tmp # git clone https://github.com/NVIDIA/Megatron-LM # PYTHONPATH=/tmp/Megatron-LM python src/transformers/models/megatron_gpt2/convert_megatron_gpt2_checkpoint.py ... # # if you already have it cloned elsewhere, simply adjust the path to the existing path # # If the training was done using a Megatron-LM fork, e.g., # https://github.com/microsoft/Megatron-DeepSpeed/ then chances are that you need to have that one # in your path, i.e., /path/to/Megatron-DeepSpeed/ # import argparse import os import re import zipfile import torch from transformers import AutoTokenizer, GPTaConfig def A ( _UpperCAmelCase : Tuple , _UpperCAmelCase : Dict , _UpperCAmelCase : Union[str, Any]=0 ) -> Dict: '''simple docstring''' # Format the message. if name is None: _UpperCAmelCase = None else: _UpperCAmelCase = '.' * max(0 , spaces - 2 ) + '# {:' + str(50 - spaces ) + 's}' _UpperCAmelCase = fmt.format(_UpperCAmelCase ) # Print and recurse (if needed). if isinstance(_UpperCAmelCase , _UpperCAmelCase ): if msg is not None: print(_UpperCAmelCase ) for k in val.keys(): recursive_print(_UpperCAmelCase , val[k] , spaces + 2 ) elif isinstance(_UpperCAmelCase , torch.Tensor ): print(_UpperCAmelCase , ':' , val.size() ) else: print(_UpperCAmelCase , ':' , _UpperCAmelCase ) def A ( _UpperCAmelCase : Any , _UpperCAmelCase : str , _UpperCAmelCase : str , _UpperCAmelCase : Tuple , _UpperCAmelCase : Tuple ) -> int: '''simple docstring''' # Permutes layout of param tensor to [num_splits * num_heads * hidden_size, :] # for compatibility with later versions of NVIDIA Megatron-LM. # The inverse operation is performed inside Megatron-LM to read checkpoints: # https://github.com/NVIDIA/Megatron-LM/blob/v2.4/megatron/checkpointing.py#L209 # If param is the weight tensor of the self-attention block, the returned tensor # will have to be transposed one more time to be read by HuggingFace GPT2. _UpperCAmelCase = param.size() if checkpoint_version == 1.0: # version 1.0 stores [num_heads * hidden_size * num_splits, :] _UpperCAmelCase = (num_heads, hidden_size, num_splits) + input_shape[1:] _UpperCAmelCase = param.view(*_UpperCAmelCase ) _UpperCAmelCase = param.transpose(0 , 2 ) _UpperCAmelCase = param.transpose(1 , 2 ).contiguous() elif checkpoint_version >= 2.0: # other versions store [num_heads * num_splits * hidden_size, :] _UpperCAmelCase = (num_heads, num_splits, hidden_size) + input_shape[1:] _UpperCAmelCase = param.view(*_UpperCAmelCase ) _UpperCAmelCase = param.transpose(0 , 1 ).contiguous() _UpperCAmelCase = param.view(*_UpperCAmelCase ) return param def A ( _UpperCAmelCase : List[Any] , _UpperCAmelCase : int , _UpperCAmelCase : Optional[int] ) -> int: '''simple docstring''' # The converted output model. _UpperCAmelCase = {} # old versions did not store training args _UpperCAmelCase = input_state_dict.get('args' , _UpperCAmelCase ) if ds_args is not None: # do not make the user write a config file when the exact dimensions/sizes are already in the checkpoint # from pprint import pprint # pprint(vars(ds_args)) _UpperCAmelCase = ds_args.padded_vocab_size _UpperCAmelCase = ds_args.max_position_embeddings _UpperCAmelCase = ds_args.hidden_size _UpperCAmelCase = ds_args.num_layers _UpperCAmelCase = ds_args.num_attention_heads _UpperCAmelCase = ds_args.ffn_hidden_size # pprint(config) # The number of heads. _UpperCAmelCase = config.n_head # The hidden_size per head. _UpperCAmelCase = config.n_embd // config.n_head # Megatron-LM checkpoint version if "checkpoint_version" in input_state_dict.keys(): _UpperCAmelCase = input_state_dict['checkpoint_version'] else: _UpperCAmelCase = 0.0 # The model. _UpperCAmelCase = input_state_dict['model'] # The language model. _UpperCAmelCase = model['language_model'] # The embeddings. _UpperCAmelCase = lm['embedding'] # The word embeddings. _UpperCAmelCase = embeddings['word_embeddings']['weight'] # Truncate the embedding table to vocab_size rows. _UpperCAmelCase = word_embeddings[: config.vocab_size, :] _UpperCAmelCase = word_embeddings # The position embeddings. _UpperCAmelCase = embeddings['position_embeddings']['weight'] # Read the causal mask dimension (seqlen). [max_sequence_length, hidden_size] _UpperCAmelCase = pos_embeddings.size(0 ) if n_positions != config.n_positions: raise ValueError( F"pos_embeddings.max_sequence_length={n_positions} and config.n_positions={config.n_positions} don't match" ) # Store the position embeddings. _UpperCAmelCase = pos_embeddings # The transformer. _UpperCAmelCase = lm['transformer'] if 'transformer' in lm.keys() else lm['encoder'] # The regex to extract layer names. _UpperCAmelCase = re.compile(R'layers\.(\d+)\.([a-z0-9_.]+)\.([a-z]+)' ) # The simple map of names for "automated" rules. _UpperCAmelCase = { 'attention.dense': '.attn.c_proj.', 'self_attention.dense': '.attn.c_proj.', 'mlp.dense_h_to_4h': '.mlp.c_fc.', 'mlp.dense_4h_to_h': '.mlp.c_proj.', } # Extract the layers. for key, val in transformer.items(): # Match the name. _UpperCAmelCase = layer_re.match(_UpperCAmelCase ) # Stop if that's not a layer if m is None: break # The index of the layer. _UpperCAmelCase = int(m.group(1 ) ) # The name of the operation. _UpperCAmelCase = m.group(2 ) # Is it a weight or a bias? _UpperCAmelCase = m.group(3 ) # The name of the layer. _UpperCAmelCase = F"transformer.h.{layer_idx}" # For layernorm(s), simply store the layer norm. if op_name.endswith('layernorm' ): _UpperCAmelCase = 'ln_1' if op_name.startswith('input' ) else 'ln_2' _UpperCAmelCase = val # Transpose the QKV matrix. elif ( op_name == "attention.query_key_value" or op_name == "self_attention.query_key_value" ) and weight_or_bias == "weight": # Insert a tensor of 1x1xDxD bias. _UpperCAmelCase = torch.tril(torch.ones((n_positions, n_positions) , dtype=torch.floataa ) ).view( 1 , 1 , _UpperCAmelCase , _UpperCAmelCase ) _UpperCAmelCase = causal_mask # Insert a "dummy" tensor for masked_bias. _UpperCAmelCase = torch.tensor(-1E4 , dtype=torch.floataa ) _UpperCAmelCase = masked_bias _UpperCAmelCase = fix_query_key_value_ordering(_UpperCAmelCase , _UpperCAmelCase , 3 , _UpperCAmelCase , _UpperCAmelCase ) # Megatron stores (3*D) x D but transformers-GPT2 expects D x 3*D. _UpperCAmelCase = out_val.transpose(0 , 1 ).contiguous() # Store. _UpperCAmelCase = out_val # Transpose the bias. elif ( op_name == "attention.query_key_value" or op_name == "self_attention.query_key_value" ) and weight_or_bias == "bias": _UpperCAmelCase = fix_query_key_value_ordering(_UpperCAmelCase , _UpperCAmelCase , 3 , _UpperCAmelCase , _UpperCAmelCase ) # Store. No change of shape. _UpperCAmelCase = out_val # Transpose the weights. elif weight_or_bias == "weight": _UpperCAmelCase = megatron_to_transformers[op_name] _UpperCAmelCase = val.transpose(0 , 1 ) # Copy the bias. elif weight_or_bias == "bias": _UpperCAmelCase = megatron_to_transformers[op_name] _UpperCAmelCase = val # DEBUG. assert config.n_layer == layer_idx + 1 # The final layernorm. _UpperCAmelCase = transformer['final_layernorm.weight'] _UpperCAmelCase = transformer['final_layernorm.bias'] # For LM head, transformers' wants the matrix to weight embeddings. _UpperCAmelCase = word_embeddings # It should be done! return output_state_dict def A ( ) -> Dict: '''simple docstring''' # Create the argument parser. _UpperCAmelCase = argparse.ArgumentParser() parser.add_argument('--print-checkpoint-structure' , action='store_true' ) parser.add_argument( 'path_to_checkpoint' , type=_UpperCAmelCase , help='Path to the checkpoint file (.zip archive or direct .pt file)' , ) parser.add_argument( '--config_file' , default='' , type=_UpperCAmelCase , help='An optional config json file describing the pre-trained model.' , ) _UpperCAmelCase = parser.parse_args() # Extract the basename. _UpperCAmelCase = os.path.dirname(args.path_to_checkpoint ) # Load the model. # the .zip is very optional, let's keep it for backward compatibility print(F"Extracting PyTorch state dictionary from {args.path_to_checkpoint}" ) if args.path_to_checkpoint.endswith('.zip' ): with zipfile.ZipFile(args.path_to_checkpoint , 'r' ) as checkpoint: with checkpoint.open('release/mp_rank_00/model_optim_rng.pt' ) as pytorch_dict: _UpperCAmelCase = torch.load(_UpperCAmelCase , map_location='cpu' ) else: _UpperCAmelCase = torch.load(args.path_to_checkpoint , map_location='cpu' ) _UpperCAmelCase = input_state_dict.get('args' , _UpperCAmelCase ) # Read the config, or default to the model released by NVIDIA. if args.config_file == "": if ds_args is not None: if ds_args.bias_gelu_fusion: _UpperCAmelCase = 'gelu_fast' elif ds_args.openai_gelu: _UpperCAmelCase = 'gelu_new' else: _UpperCAmelCase = 'gelu' else: # in the very early days this used to be "gelu_new" _UpperCAmelCase = 'gelu_new' # Spell out all parameters in case the defaults change. _UpperCAmelCase = GPTaConfig( vocab_size=50_257 , n_positions=1_024 , n_embd=1_024 , n_layer=24 , n_head=16 , n_inner=4_096 , activation_function=_UpperCAmelCase , resid_pdrop=0.1 , embd_pdrop=0.1 , attn_pdrop=0.1 , layer_norm_epsilon=1E-5 , initializer_range=0.02 , summary_type='cls_index' , summary_use_proj=_UpperCAmelCase , summary_activation=_UpperCAmelCase , summary_proj_to_labels=_UpperCAmelCase , summary_first_dropout=0.1 , scale_attn_weights=_UpperCAmelCase , use_cache=_UpperCAmelCase , bos_token_id=50_256 , eos_token_id=50_256 , ) else: _UpperCAmelCase = GPTaConfig.from_json_file(args.config_file ) _UpperCAmelCase = ['GPT2LMHeadModel'] # Convert. print('Converting' ) _UpperCAmelCase = convert_megatron_checkpoint(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) # Print the structure of converted state dict. if args.print_checkpoint_structure: recursive_print(_UpperCAmelCase , _UpperCAmelCase ) # Add tokenizer class info to config # see https://github.com/huggingface/transformers/issues/13906) if ds_args is not None: _UpperCAmelCase = ds_args.tokenizer_type if tokenizer_type == "GPT2BPETokenizer": _UpperCAmelCase = 'gpt2' elif tokenizer_type == "PretrainedFromHF": _UpperCAmelCase = ds_args.tokenizer_name_or_path else: raise ValueError(F"Unrecognized tokenizer_type {tokenizer_type}" ) else: _UpperCAmelCase = 'gpt2' _UpperCAmelCase = AutoTokenizer.from_pretrained(_UpperCAmelCase ) _UpperCAmelCase = type(_UpperCAmelCase ).__name__ _UpperCAmelCase = tokenizer_class # Store the config to file. print('Saving config' ) config.save_pretrained(_UpperCAmelCase ) # Save tokenizer based on args print(F"Adding {tokenizer_class} tokenizer files" ) tokenizer.save_pretrained(_UpperCAmelCase ) # Store the state_dict to file. _UpperCAmelCase = os.path.join(_UpperCAmelCase , 'pytorch_model.bin' ) print(F"Saving checkpoint to \"{output_checkpoint_file}\"" ) torch.save(_UpperCAmelCase , _UpperCAmelCase ) #################################################################################################### if __name__ == "__main__": main() ####################################################################################################
339
import numpy as np from nltk.translate import meteor_score import datasets from datasets.config import importlib_metadata, version UpperCAmelCase__ = version.parse(importlib_metadata.version("nltk")) if NLTK_VERSION >= version.Version("3.6.4"): from nltk import word_tokenize UpperCAmelCase__ = "\\n@inproceedings{banarjee2005,\n title = {{METEOR}: An Automatic Metric for {MT} Evaluation with Improved Correlation with Human Judgments},\n author = {Banerjee, Satanjeev and Lavie, Alon},\n booktitle = {Proceedings of the {ACL} Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization},\n month = jun,\n year = {2005},\n address = {Ann Arbor, Michigan},\n publisher = {Association for Computational Linguistics},\n url = {https://www.aclweb.org/anthology/W05-0909},\n pages = {65--72},\n}\n" UpperCAmelCase__ = "\\nMETEOR, an automatic metric for machine translation evaluation\nthat is based on a generalized concept of unigram matching between the\nmachine-produced translation and human-produced reference translations.\nUnigrams can be matched based on their surface forms, stemmed forms,\nand meanings; furthermore, METEOR can be easily extended to include more\nadvanced matching strategies. Once all generalized unigram matches\nbetween the two strings have been found, METEOR computes a score for\nthis matching using a combination of unigram-precision, unigram-recall, and\na measure of fragmentation that is designed to directly capture how\nwell-ordered the matched words in the machine translation are in relation\nto the reference.\n\nMETEOR gets an R correlation value of 0.347 with human evaluation on the Arabic\ndata and 0.331 on the Chinese data. This is shown to be an improvement on\nusing simply unigram-precision, unigram-recall and their harmonic F1\ncombination.\n" UpperCAmelCase__ = "\nComputes METEOR score of translated segments against one or more references.\nArgs:\n predictions: list of predictions to score. Each prediction\n should be a string with tokens separated by spaces.\n references: list of reference for each prediction. Each\n reference should be a string with tokens separated by spaces.\n alpha: Parameter for controlling relative weights of precision and recall. default: 0.9\n beta: Parameter for controlling shape of penalty as a function of fragmentation. default: 3\n gamma: Relative weight assigned to fragmentation penalty. default: 0.5\nReturns:\n 'meteor': meteor score.\nExamples:\n\n >>> meteor = datasets.load_metric('meteor')\n >>> predictions = [\"It is a guide to action which ensures that the military always obeys the commands of the party\"]\n >>> references = [\"It is a guide to action that ensures that the military will forever heed Party commands\"]\n >>> results = meteor.compute(predictions=predictions, references=references)\n >>> print(round(results[\"meteor\"], 4))\n 0.6944\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class __lowerCAmelCase ( datasets.Metric ): def _lowerCamelCase ( self : List[Any]) -> List[Any]: """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': datasets.Value('string' , id='sequence'), 'references': datasets.Value('string' , id='sequence'), }) , codebase_urls=['https://github.com/nltk/nltk/blob/develop/nltk/translate/meteor_score.py'] , reference_urls=[ 'https://www.nltk.org/api/nltk.translate.html#module-nltk.translate.meteor_score', 'https://en.wikipedia.org/wiki/METEOR', ] , ) def _lowerCamelCase ( self : Optional[Any] , A : List[str]) -> List[Any]: """simple docstring""" import nltk nltk.download('wordnet') if NLTK_VERSION >= version.Version('3.6.5'): nltk.download('punkt') if NLTK_VERSION >= version.Version('3.6.6'): nltk.download('omw-1.4') def _lowerCamelCase ( self : Optional[Any] , A : Tuple , A : Optional[int] , A : List[Any]=0.9 , A : Optional[Any]=3 , A : Optional[int]=0.5) -> Any: """simple docstring""" if NLTK_VERSION >= version.Version('3.6.5'): _UpperCAmelCase = [ meteor_score.single_meteor_score( word_tokenize(A) , word_tokenize(A) , alpha=A , beta=A , gamma=A) for ref, pred in zip(A , A) ] else: _UpperCAmelCase = [ meteor_score.single_meteor_score(A , A , alpha=A , beta=A , gamma=A) for ref, pred in zip(A , A) ] return {"meteor": np.mean(A)}
339
1
from typing import List, Optional from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCAmelCase__ = logging.get_logger(__name__) UpperCAmelCase__ = { "huggingface/autoformer-tourism-monthly": "https://huggingface.co/huggingface/autoformer-tourism-monthly/resolve/main/config.json", } class __lowerCAmelCase ( A ): UpperCamelCase = '''autoformer''' UpperCamelCase = { '''hidden_size''': '''d_model''', '''num_attention_heads''': '''encoder_attention_heads''', '''num_hidden_layers''': '''encoder_layers''', } def __init__( self : Any , A : Optional[int] = None , A : Optional[int] = None , A : str = "student_t" , A : str = "nll" , A : int = 1 , A : List[int] = [1, 2, 3, 4, 5, 6, 7] , A : bool = True , A : int = 0 , A : int = 0 , A : int = 0 , A : int = 0 , A : Optional[List[int]] = None , A : Optional[List[int]] = None , A : int = 64 , A : int = 2 , A : int = 2 , A : int = 2 , A : int = 2 , A : int = 32 , A : int = 32 , A : str = "gelu" , A : float = 0.1 , A : float = 0.1 , A : float = 0.1 , A : float = 0.1 , A : float = 0.1 , A : int = 1_00 , A : float = 0.0_2 , A : bool = True , A : List[str]=True , A : int = 10 , A : int = 25 , A : int = 3 , **A : Tuple , ) -> str: """simple docstring""" _UpperCAmelCase = prediction_length _UpperCAmelCase = context_length if context_length is not None else prediction_length _UpperCAmelCase = distribution_output _UpperCAmelCase = loss _UpperCAmelCase = input_size _UpperCAmelCase = num_time_features _UpperCAmelCase = lags_sequence _UpperCAmelCase = scaling _UpperCAmelCase = num_dynamic_real_features _UpperCAmelCase = num_static_real_features _UpperCAmelCase = num_static_categorical_features if cardinality is not None and num_static_categorical_features > 0: if len(A) != num_static_categorical_features: raise ValueError( 'The cardinality should be a list of the same length as `num_static_categorical_features`') _UpperCAmelCase = cardinality else: _UpperCAmelCase = [0] if embedding_dimension is not None and num_static_categorical_features > 0: if len(A) != num_static_categorical_features: raise ValueError( 'The embedding dimension should be a list of the same length as `num_static_categorical_features`') _UpperCAmelCase = embedding_dimension else: _UpperCAmelCase = [min(50 , (cat + 1) // 2) for cat in self.cardinality] _UpperCAmelCase = num_parallel_samples # Transformer architecture configuration _UpperCAmelCase = input_size * len(self.lags_sequence) + self._number_of_features _UpperCAmelCase = d_model _UpperCAmelCase = encoder_attention_heads _UpperCAmelCase = decoder_attention_heads _UpperCAmelCase = encoder_ffn_dim _UpperCAmelCase = decoder_ffn_dim _UpperCAmelCase = encoder_layers _UpperCAmelCase = decoder_layers _UpperCAmelCase = dropout _UpperCAmelCase = attention_dropout _UpperCAmelCase = activation_dropout _UpperCAmelCase = encoder_layerdrop _UpperCAmelCase = decoder_layerdrop _UpperCAmelCase = activation_function _UpperCAmelCase = init_std _UpperCAmelCase = use_cache # Autoformer _UpperCAmelCase = label_length _UpperCAmelCase = moving_average _UpperCAmelCase = autocorrelation_factor super().__init__(is_encoder_decoder=A , **A) @property def _lowerCamelCase ( self : List[Any]) -> int: """simple docstring""" return ( sum(self.embedding_dimension) + self.num_dynamic_real_features + self.num_time_features + self.num_static_real_features + self.input_size * 2 # the log1p(abs(loc)) and log(scale) features )
339
import argparse import hashlib import os import urllib import warnings import torch from torch import nn from tqdm import tqdm from transformers import WhisperConfig, WhisperForConditionalGeneration UpperCAmelCase__ = { "tiny.en": "https://openaipublic.azureedge.net/main/whisper/models/d3dd57d32accea0b295c96e26691aa14d8822fac7d9d27d5dc00b4ca2826dd03/tiny.en.pt", "tiny": "https://openaipublic.azureedge.net/main/whisper/models/65147644a518d12f04e32d6f3b26facc3f8dd46e5390956a9424a650c0ce22b9/tiny.pt", "base.en": "https://openaipublic.azureedge.net/main/whisper/models/25a8566e1d0c1e2231d1c762132cd20e0f96a85d16145c3a00adf5d1ac670ead/base.en.pt", "base": "https://openaipublic.azureedge.net/main/whisper/models/ed3a0b6b1c0edf879ad9b11b1af5a0e6ab5db9205f891f668f8b0e6c6326e34e/base.pt", "small.en": "https://openaipublic.azureedge.net/main/whisper/models/f953ad0fd29cacd07d5a9eda5624af0f6bcf2258be67c92b79389873d91e0872/small.en.pt", "small": "https://openaipublic.azureedge.net/main/whisper/models/9ecf779972d90ba49c06d968637d720dd632c55bbf19d441fb42bf17a411e794/small.pt", "medium.en": "https://openaipublic.azureedge.net/main/whisper/models/d7440d1dc186f76616474e0ff0b3b6b879abc9d1a4926b7adfa41db2d497ab4f/medium.en.pt", "medium": "https://openaipublic.azureedge.net/main/whisper/models/345ae4da62f9b3d59415adc60127b97c714f32e89e936602e85993674d08dcb1/medium.pt", "large": "https://openaipublic.azureedge.net/main/whisper/models/e4b87e7e0bf463eb8e6956e646f1e277e901512310def2c24bf0e11bd3c28e9a/large.pt", "large-v2": "https://openaipublic.azureedge.net/main/whisper/models/81f7c96c852ee8fc832187b0132e569d6c3065a3252ed18e56effd0b6a73e524/large-v2.pt", } def A ( _UpperCAmelCase : Optional[int] ) -> str: '''simple docstring''' _UpperCAmelCase = ['layers', 'blocks'] for k in ignore_keys: state_dict.pop(_UpperCAmelCase , _UpperCAmelCase ) UpperCAmelCase__ = { "blocks": "layers", "mlp.0": "fc1", "mlp.2": "fc2", "mlp_ln": "final_layer_norm", ".attn.query": ".self_attn.q_proj", ".attn.key": ".self_attn.k_proj", ".attn.value": ".self_attn.v_proj", ".attn_ln": ".self_attn_layer_norm", ".attn.out": ".self_attn.out_proj", ".cross_attn.query": ".encoder_attn.q_proj", ".cross_attn.key": ".encoder_attn.k_proj", ".cross_attn.value": ".encoder_attn.v_proj", ".cross_attn_ln": ".encoder_attn_layer_norm", ".cross_attn.out": ".encoder_attn.out_proj", "decoder.ln.": "decoder.layer_norm.", "encoder.ln.": "encoder.layer_norm.", "token_embedding": "embed_tokens", "encoder.positional_embedding": "encoder.embed_positions.weight", "decoder.positional_embedding": "decoder.embed_positions.weight", "ln_post": "layer_norm", } def A ( _UpperCAmelCase : Dict ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = list(s_dict.keys() ) for key in keys: _UpperCAmelCase = key for k, v in WHISPER_MAPPING.items(): if k in key: _UpperCAmelCase = new_key.replace(_UpperCAmelCase , _UpperCAmelCase ) print(F"{key} -> {new_key}" ) _UpperCAmelCase = s_dict.pop(_UpperCAmelCase ) return s_dict def A ( _UpperCAmelCase : List[Any] ) -> Union[str, Any]: '''simple docstring''' _UpperCAmelCase , _UpperCAmelCase = emb.weight.shape _UpperCAmelCase = nn.Linear(_UpperCAmelCase , _UpperCAmelCase , bias=_UpperCAmelCase ) _UpperCAmelCase = emb.weight.data return lin_layer def A ( _UpperCAmelCase : str , _UpperCAmelCase : str ) -> bytes: '''simple docstring''' os.makedirs(_UpperCAmelCase , exist_ok=_UpperCAmelCase ) _UpperCAmelCase = os.path.basename(_UpperCAmelCase ) _UpperCAmelCase = url.split('/' )[-2] _UpperCAmelCase = os.path.join(_UpperCAmelCase , _UpperCAmelCase ) if os.path.exists(_UpperCAmelCase ) and not os.path.isfile(_UpperCAmelCase ): raise RuntimeError(F"{download_target} exists and is not a regular file" ) if os.path.isfile(_UpperCAmelCase ): _UpperCAmelCase = open(_UpperCAmelCase , 'rb' ).read() if hashlib.shaaaa(_UpperCAmelCase ).hexdigest() == expected_shaaaa: return model_bytes else: warnings.warn(F"{download_target} exists, but the SHA256 checksum does not match; re-downloading the file" ) with urllib.request.urlopen(_UpperCAmelCase ) as source, open(_UpperCAmelCase , 'wb' ) as output: with tqdm( total=int(source.info().get('Content-Length' ) ) , ncols=80 , unit='iB' , unit_scale=_UpperCAmelCase , unit_divisor=1_024 ) as loop: while True: _UpperCAmelCase = source.read(8_192 ) if not buffer: break output.write(_UpperCAmelCase ) loop.update(len(_UpperCAmelCase ) ) _UpperCAmelCase = open(_UpperCAmelCase , 'rb' ).read() if hashlib.shaaaa(_UpperCAmelCase ).hexdigest() != expected_shaaaa: raise RuntimeError( 'Model has been downloaded but the SHA256 checksum does not not match. Please retry loading the model.' ) return model_bytes def A ( _UpperCAmelCase : List[Any] , _UpperCAmelCase : Any ) -> Optional[int]: '''simple docstring''' if ".pt" not in checkpoint_path: _UpperCAmelCase = _download(_MODELS[checkpoint_path] ) else: _UpperCAmelCase = torch.load(_UpperCAmelCase , map_location='cpu' ) _UpperCAmelCase = original_checkpoint['dims'] _UpperCAmelCase = original_checkpoint['model_state_dict'] _UpperCAmelCase = state_dict['decoder.token_embedding.weight'] remove_ignore_keys_(_UpperCAmelCase ) rename_keys(_UpperCAmelCase ) _UpperCAmelCase = True _UpperCAmelCase = state_dict['decoder.layers.0.fc1.weight'].shape[0] _UpperCAmelCase = WhisperConfig( vocab_size=dimensions['n_vocab'] , encoder_ffn_dim=_UpperCAmelCase , decoder_ffn_dim=_UpperCAmelCase , num_mel_bins=dimensions['n_mels'] , d_model=dimensions['n_audio_state'] , max_target_positions=dimensions['n_text_ctx'] , encoder_layers=dimensions['n_audio_layer'] , encoder_attention_heads=dimensions['n_audio_head'] , decoder_layers=dimensions['n_text_layer'] , decoder_attention_heads=dimensions['n_text_state'] , max_source_positions=dimensions['n_audio_ctx'] , ) _UpperCAmelCase = WhisperForConditionalGeneration(_UpperCAmelCase ) _UpperCAmelCase , _UpperCAmelCase = model.model.load_state_dict(_UpperCAmelCase , strict=_UpperCAmelCase ) if len(_UpperCAmelCase ) > 0 and not set(_UpperCAmelCase ) <= { "encoder.embed_positions.weights", "decoder.embed_positions.weights", }: raise ValueError( 'Only `encoder.embed_positions.weights` and `decoder.embed_positions.weights` are allowed to be missing,' F" but all the following weights are missing {missing}" ) if tie_embeds: _UpperCAmelCase = make_linear_from_emb(model.model.decoder.embed_tokens ) else: _UpperCAmelCase = proj_out_weights model.save_pretrained(_UpperCAmelCase ) if __name__ == "__main__": UpperCAmelCase__ = argparse.ArgumentParser() # # Required parameters parser.add_argument("--checkpoint_path", type=str, help="Patht to the downloaded checkpoints") parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.") UpperCAmelCase__ = parser.parse_args() convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)
339
1
import itertools import json import os import unittest from transformers import AddedToken, RobertaTokenizer, RobertaTokenizerFast from transformers.models.roberta.tokenization_roberta import VOCAB_FILES_NAMES from transformers.testing_utils import require_tokenizers, slow from ...test_tokenization_common import TokenizerTesterMixin @require_tokenizers class __lowerCAmelCase ( A , unittest.TestCase ): UpperCamelCase = RobertaTokenizer UpperCamelCase = RobertaTokenizerFast UpperCamelCase = True UpperCamelCase = {'''cls_token''': '''<s>'''} def _lowerCamelCase ( self : List[str]) -> str: """simple docstring""" super().setUp() # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt _UpperCAmelCase = [ 'l', 'o', 'w', 'e', 'r', 's', 't', 'i', 'd', 'n', '\u0120', '\u0120l', '\u0120n', '\u0120lo', '\u0120low', 'er', '\u0120lowest', '\u0120newer', '\u0120wider', '<unk>', ] _UpperCAmelCase = dict(zip(A , range(len(A)))) _UpperCAmelCase = ['#version: 0.2', '\u0120 l', '\u0120l o', '\u0120lo w', 'e r', ''] _UpperCAmelCase = {'unk_token': '<unk>'} _UpperCAmelCase = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['vocab_file']) _UpperCAmelCase = 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(A) + '\n') with open(self.merges_file , 'w' , encoding='utf-8') as fp: fp.write('\n'.join(A)) def _lowerCamelCase ( self : Optional[Any] , **A : str) -> List[Any]: """simple docstring""" kwargs.update(self.special_tokens_map) return self.tokenizer_class.from_pretrained(self.tmpdirname , **A) def _lowerCamelCase ( self : Optional[Any] , **A : List[str]) -> Optional[int]: """simple docstring""" kwargs.update(self.special_tokens_map) return RobertaTokenizerFast.from_pretrained(self.tmpdirname , **A) def _lowerCamelCase ( self : int , A : Optional[int]) -> Any: """simple docstring""" _UpperCAmelCase = 'lower newer' _UpperCAmelCase = 'lower newer' return input_text, output_text def _lowerCamelCase ( self : Tuple) -> Any: """simple docstring""" _UpperCAmelCase = self.tokenizer_class(self.vocab_file , self.merges_file , **self.special_tokens_map) _UpperCAmelCase = 'lower newer' _UpperCAmelCase = ['l', 'o', 'w', 'er', '\u0120', 'n', 'e', 'w', 'er'] _UpperCAmelCase = tokenizer.tokenize(A) # , add_prefix_space=True) self.assertListEqual(A , A) _UpperCAmelCase = tokens + [tokenizer.unk_token] _UpperCAmelCase = [0, 1, 2, 15, 10, 9, 3, 2, 15, 19] self.assertListEqual(tokenizer.convert_tokens_to_ids(A) , A) def _lowerCamelCase ( self : Optional[Any]) -> int: """simple docstring""" _UpperCAmelCase = self.get_tokenizer() self.assertListEqual(tokenizer.encode('Hello world!' , add_special_tokens=A) , [0, 3_14_14, 2_32, 3_28, 2]) self.assertListEqual( tokenizer.encode('Hello world! cécé herlolip 418' , add_special_tokens=A) , [0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 4_60_78, 15_88, 2] , ) @slow def _lowerCamelCase ( self : Optional[int]) -> List[str]: """simple docstring""" _UpperCAmelCase = self.tokenizer_class.from_pretrained('roberta-base') _UpperCAmelCase = tokenizer.encode('sequence builders' , add_special_tokens=A) _UpperCAmelCase = tokenizer.encode('multi-sequence build' , add_special_tokens=A) _UpperCAmelCase = tokenizer.encode( 'sequence builders' , add_special_tokens=A , add_prefix_space=A) _UpperCAmelCase = tokenizer.encode( 'sequence builders' , 'multi-sequence build' , add_special_tokens=A , add_prefix_space=A) _UpperCAmelCase = tokenizer.build_inputs_with_special_tokens(A) _UpperCAmelCase = tokenizer.build_inputs_with_special_tokens(A , A) assert encoded_sentence == encoded_text_from_decode assert encoded_pair == encoded_pair_from_decode def _lowerCamelCase ( self : List[str]) -> List[Any]: """simple docstring""" _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = 'Encode this sequence.' _UpperCAmelCase = tokenizer.byte_encoder[' '.encode('utf-8')[0]] # Testing encoder arguments _UpperCAmelCase = tokenizer.encode(A , add_special_tokens=A , add_prefix_space=A) _UpperCAmelCase = tokenizer.convert_ids_to_tokens(encoded[0])[0] self.assertNotEqual(A , A) _UpperCAmelCase = tokenizer.encode(A , add_special_tokens=A , add_prefix_space=A) _UpperCAmelCase = tokenizer.convert_ids_to_tokens(encoded[0])[0] self.assertEqual(A , A) tokenizer.add_special_tokens({'bos_token': '<s>'}) _UpperCAmelCase = tokenizer.encode(A , add_special_tokens=A) _UpperCAmelCase = tokenizer.convert_ids_to_tokens(encoded[1])[0] self.assertNotEqual(A , A) # Testing spaces after special tokens _UpperCAmelCase = '<mask>' tokenizer.add_special_tokens( {'mask_token': AddedToken(A , lstrip=A , rstrip=A)}) # mask token has a left space _UpperCAmelCase = tokenizer.convert_tokens_to_ids(A) _UpperCAmelCase = 'Encode <mask> sequence' _UpperCAmelCase = 'Encode <mask>sequence' _UpperCAmelCase = tokenizer.encode(A) _UpperCAmelCase = encoded.index(A) _UpperCAmelCase = tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1])[0] self.assertEqual(A , A) _UpperCAmelCase = tokenizer.encode(A) _UpperCAmelCase = encoded.index(A) _UpperCAmelCase = tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1])[0] self.assertNotEqual(A , A) def _lowerCamelCase ( self : str) -> Union[str, Any]: """simple docstring""" pass def _lowerCamelCase ( self : Any) -> Any: """simple docstring""" for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"): _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained(A , **A) _UpperCAmelCase = self.tokenizer_class.from_pretrained(A , **A) _UpperCAmelCase = 'A, <mask> AllenNLP sentence.' _UpperCAmelCase = tokenizer_r.encode_plus(A , add_special_tokens=A , return_token_type_ids=A) _UpperCAmelCase = tokenizer_p.encode_plus(A , add_special_tokens=A , return_token_type_ids=A) # token_type_ids should put 0 everywhere self.assertEqual(sum(tokens_r['token_type_ids']) , sum(tokens_p['token_type_ids'])) # attention_mask should put 1 everywhere, so sum over length should be 1 self.assertEqual( sum(tokens_r['attention_mask']) / len(tokens_r['attention_mask']) , sum(tokens_p['attention_mask']) / len(tokens_p['attention_mask']) , ) _UpperCAmelCase = tokenizer_r.convert_ids_to_tokens(tokens_r['input_ids']) _UpperCAmelCase = tokenizer_p.convert_ids_to_tokens(tokens_p['input_ids']) # Rust correctly handles the space before the mask while python doesnt self.assertSequenceEqual(tokens_p['input_ids'] , [0, 2_50, 6, 5_02_64, 38_23, 4_87, 2_19_92, 36_45, 4, 2]) self.assertSequenceEqual(tokens_r['input_ids'] , [0, 2_50, 6, 5_02_64, 38_23, 4_87, 2_19_92, 36_45, 4, 2]) self.assertSequenceEqual( A , ['<s>', 'A', ',', '<mask>', 'ĠAllen', 'N', 'LP', 'Ġsentence', '.', '</s>']) self.assertSequenceEqual( A , ['<s>', 'A', ',', '<mask>', 'ĠAllen', 'N', 'LP', 'Ġsentence', '.', '</s>']) def _lowerCamelCase ( self : str) -> int: """simple docstring""" for trim_offsets, add_prefix_space in itertools.product([True, False] , repeat=2): _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained( self.tmpdirname , use_fast=A , add_prefix_space=A , trim_offsets=A) _UpperCAmelCase = json.loads(tokenizer_r.backend_tokenizer.pre_tokenizer.__getstate__()) _UpperCAmelCase = json.loads(tokenizer_r.backend_tokenizer.post_processor.__getstate__()) self.assertEqual(pre_tokenizer_state['add_prefix_space'] , A) self.assertEqual(post_processor_state['add_prefix_space'] , A) self.assertEqual(post_processor_state['trim_offsets'] , A) def _lowerCamelCase ( self : Union[str, Any]) -> Tuple: """simple docstring""" for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"): _UpperCAmelCase = 'hello' # `hello` is a token in the vocabulary of `pretrained_name` _UpperCAmelCase = F"{text_of_1_token} {text_of_1_token}" _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained( A , use_fast=A , add_prefix_space=A , trim_offsets=A) _UpperCAmelCase = tokenizer_r(A , return_offsets_mapping=A , add_special_tokens=A) self.assertEqual(encoding.offset_mapping[0] , (0, len(A))) self.assertEqual( encoding.offset_mapping[1] , (len(A) + 1, len(A) + 1 + len(A)) , ) _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained( A , use_fast=A , add_prefix_space=A , trim_offsets=A) _UpperCAmelCase = tokenizer_r(A , return_offsets_mapping=A , add_special_tokens=A) self.assertEqual(encoding.offset_mapping[0] , (0, len(A))) self.assertEqual( encoding.offset_mapping[1] , (len(A) + 1, len(A) + 1 + len(A)) , ) _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained( A , use_fast=A , add_prefix_space=A , trim_offsets=A) _UpperCAmelCase = tokenizer_r(A , return_offsets_mapping=A , add_special_tokens=A) self.assertEqual(encoding.offset_mapping[0] , (0, len(A))) self.assertEqual( encoding.offset_mapping[1] , (len(A), len(A) + 1 + len(A)) , ) _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained( A , use_fast=A , add_prefix_space=A , trim_offsets=A) _UpperCAmelCase = tokenizer_r(A , return_offsets_mapping=A , add_special_tokens=A) self.assertEqual(encoding.offset_mapping[0] , (0, len(A))) self.assertEqual( encoding.offset_mapping[1] , (len(A), len(A) + 1 + len(A)) , ) _UpperCAmelCase = F" {text}" # tokenizer_r = self.rust_tokenizer_class.from_pretrained( # pretrained_name, use_fast=True, add_prefix_space=True, trim_offsets=True # ) # encoding = tokenizer_r(text, return_offsets_mapping=True, add_special_tokens=False) # self.assertEqual(encoding.offset_mapping[0], (1, 1 + len(text_of_1_token))) # self.assertEqual( # encoding.offset_mapping[1], # (1 + len(text_of_1_token) + 1, 1 + len(text_of_1_token) + 1 + len(text_of_1_token)), # ) _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained( A , use_fast=A , add_prefix_space=A , trim_offsets=A) _UpperCAmelCase = tokenizer_r(A , return_offsets_mapping=A , add_special_tokens=A) self.assertEqual(encoding.offset_mapping[0] , (1, 1 + len(A))) self.assertEqual( encoding.offset_mapping[1] , (1 + len(A) + 1, 1 + len(A) + 1 + len(A)) , ) _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained( A , use_fast=A , add_prefix_space=A , trim_offsets=A) _UpperCAmelCase = tokenizer_r(A , return_offsets_mapping=A , add_special_tokens=A) self.assertEqual(encoding.offset_mapping[0] , (0, 1 + len(A))) self.assertEqual( encoding.offset_mapping[1] , (1 + len(A), 1 + len(A) + 1 + len(A)) , ) _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained( A , use_fast=A , add_prefix_space=A , trim_offsets=A) _UpperCAmelCase = tokenizer_r(A , return_offsets_mapping=A , add_special_tokens=A) self.assertEqual(encoding.offset_mapping[0] , (0, 1 + len(A))) self.assertEqual( encoding.offset_mapping[1] , (1 + len(A), 1 + len(A) + 1 + len(A)) , )
339
from typing import List import datasets from datasets.tasks import AudioClassification from ..folder_based_builder import folder_based_builder UpperCAmelCase__ = datasets.utils.logging.get_logger(__name__) class __lowerCAmelCase ( folder_based_builder.FolderBasedBuilderConfig ): UpperCamelCase = None UpperCamelCase = None class __lowerCAmelCase ( folder_based_builder.FolderBasedBuilder ): UpperCamelCase = datasets.Audio() UpperCamelCase = '''audio''' UpperCamelCase = AudioFolderConfig UpperCamelCase = 42 # definition at the bottom of the script UpperCamelCase = AudioClassification(audio_column='''audio''' , label_column='''label''' ) UpperCAmelCase__ = [ ".aiff", ".au", ".avr", ".caf", ".flac", ".htk", ".svx", ".mat4", ".mat5", ".mpc2k", ".ogg", ".paf", ".pvf", ".raw", ".rf64", ".sd2", ".sds", ".ircam", ".voc", ".w64", ".wav", ".nist", ".wavex", ".wve", ".xi", ".mp3", ".opus", ] UpperCAmelCase__ = AUDIO_EXTENSIONS
339
1
from typing import Any, Dict, List, Union from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends from .base import PIPELINE_INIT_ARGS, ChunkPipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_torch_available(): import torch from transformers.modeling_outputs import BaseModelOutput from ..models.auto.modeling_auto import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING UpperCAmelCase__ = logging.get_logger(__name__) @add_end_docstrings(A ) class __lowerCAmelCase ( A ): def __init__( self : str , **A : Optional[int]) -> List[Any]: """simple docstring""" super().__init__(**A) if self.framework == "tf": raise ValueError(F"The {self.__class__} is only available in PyTorch.") requires_backends(self , 'vision') self.check_model_type(A) def __call__( self : Tuple , A : Union[str, "Image.Image", List[Dict[str, Any]]] , A : Union[str, List[str]] = None , **A : Optional[int] , ) -> List[Any]: """simple docstring""" if "text_queries" in kwargs: _UpperCAmelCase = kwargs.pop('text_queries') if isinstance(A , (str, Image.Image)): _UpperCAmelCase = {'image': image, 'candidate_labels': candidate_labels} else: _UpperCAmelCase = image _UpperCAmelCase = super().__call__(A , **A) return results def _lowerCamelCase ( self : Union[str, Any] , **A : Union[str, Any]) -> List[Any]: """simple docstring""" _UpperCAmelCase = {} if "threshold" in kwargs: _UpperCAmelCase = kwargs['threshold'] if "top_k" in kwargs: _UpperCAmelCase = kwargs['top_k'] return {}, {}, postprocess_params def _lowerCamelCase ( self : Optional[Any] , A : Tuple) -> List[Any]: """simple docstring""" _UpperCAmelCase = load_image(inputs['image']) _UpperCAmelCase = inputs['candidate_labels'] if isinstance(A , A): _UpperCAmelCase = candidate_labels.split(',') _UpperCAmelCase = torch.tensor([[image.height, image.width]] , dtype=torch.intaa) for i, candidate_label in enumerate(A): _UpperCAmelCase = self.tokenizer(A , return_tensors=self.framework) _UpperCAmelCase = self.image_processor(A , return_tensors=self.framework) yield { "is_last": i == len(A) - 1, "target_size": target_size, "candidate_label": candidate_label, **text_inputs, **image_features, } def _lowerCamelCase ( self : List[str] , A : Optional[Any]) -> Optional[int]: """simple docstring""" _UpperCAmelCase = model_inputs.pop('target_size') _UpperCAmelCase = model_inputs.pop('candidate_label') _UpperCAmelCase = model_inputs.pop('is_last') _UpperCAmelCase = self.model(**A) _UpperCAmelCase = {'target_size': target_size, 'candidate_label': candidate_label, 'is_last': is_last, **outputs} return model_outputs def _lowerCamelCase ( self : List[str] , A : Optional[Any] , A : Union[str, Any]=0.1 , A : Dict=None) -> Dict: """simple docstring""" _UpperCAmelCase = [] for model_output in model_outputs: _UpperCAmelCase = model_output['candidate_label'] _UpperCAmelCase = BaseModelOutput(A) _UpperCAmelCase = self.image_processor.post_process_object_detection( outputs=A , threshold=A , target_sizes=model_output['target_size'])[0] for index in outputs["scores"].nonzero(): _UpperCAmelCase = outputs['scores'][index].item() _UpperCAmelCase = self._get_bounding_box(outputs['boxes'][index][0]) _UpperCAmelCase = {'score': score, 'label': label, 'box': box} results.append(A) _UpperCAmelCase = sorted(A , key=lambda A: x["score"] , reverse=A) if top_k: _UpperCAmelCase = results[:top_k] return results def _lowerCamelCase ( self : List[Any] , A : "torch.Tensor") -> Dict[str, int]: """simple docstring""" if self.framework != "pt": raise ValueError('The ZeroShotObjectDetectionPipeline is only available in PyTorch.') _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = box.int().tolist() _UpperCAmelCase = { 'xmin': xmin, 'ymin': ymin, 'xmax': xmax, 'ymax': ymax, } return bbox
339
import sys from collections import defaultdict class __lowerCAmelCase : def __init__( self : int) -> str: """simple docstring""" _UpperCAmelCase = [] def _lowerCamelCase ( self : Any , A : List[str]) -> int: """simple docstring""" return self.node_position[vertex] def _lowerCamelCase ( self : Optional[Any] , A : Optional[int] , A : str) -> List[str]: """simple docstring""" _UpperCAmelCase = pos def _lowerCamelCase ( self : Tuple , A : Tuple , A : Dict , A : List[str] , A : Optional[Any]) -> Dict: """simple docstring""" if start > size // 2 - 1: return else: if 2 * start + 2 >= size: _UpperCAmelCase = 2 * start + 1 else: if heap[2 * start + 1] < heap[2 * start + 2]: _UpperCAmelCase = 2 * start + 1 else: _UpperCAmelCase = 2 * start + 2 if heap[smallest_child] < heap[start]: _UpperCAmelCase , _UpperCAmelCase = heap[smallest_child], positions[smallest_child] _UpperCAmelCase , _UpperCAmelCase = ( heap[start], positions[start], ) _UpperCAmelCase , _UpperCAmelCase = temp, tempa _UpperCAmelCase = self.get_position(positions[smallest_child]) self.set_position( positions[smallest_child] , self.get_position(positions[start])) self.set_position(positions[start] , A) self.top_to_bottom(A , A , A , A) def _lowerCamelCase ( self : Optional[int] , A : str , A : Optional[Any] , A : Optional[int] , A : str) -> Any: """simple docstring""" _UpperCAmelCase = position[index] while index != 0: _UpperCAmelCase = int((index - 2) / 2) if index % 2 == 0 else int((index - 1) / 2) if val < heap[parent]: _UpperCAmelCase = heap[parent] _UpperCAmelCase = position[parent] self.set_position(position[parent] , A) else: _UpperCAmelCase = val _UpperCAmelCase = temp self.set_position(A , A) break _UpperCAmelCase = parent else: _UpperCAmelCase = val _UpperCAmelCase = temp self.set_position(A , 0) def _lowerCamelCase ( self : Union[str, Any] , A : Optional[int] , A : Tuple) -> str: """simple docstring""" _UpperCAmelCase = len(A) // 2 - 1 for i in range(A , -1 , -1): self.top_to_bottom(A , A , len(A) , A) def _lowerCamelCase ( self : Optional[int] , A : int , A : str) -> List[str]: """simple docstring""" _UpperCAmelCase = positions[0] _UpperCAmelCase = sys.maxsize self.top_to_bottom(A , 0 , len(A) , A) return temp def A ( _UpperCAmelCase : int ) -> Any: '''simple docstring''' _UpperCAmelCase = Heap() _UpperCAmelCase = [0] * len(_UpperCAmelCase ) _UpperCAmelCase = [-1] * len(_UpperCAmelCase ) # Neighboring Tree Vertex of selected vertex # Minimum Distance of explored vertex with neighboring vertex of partial tree # formed in graph _UpperCAmelCase = [] # Heap of Distance of vertices from their neighboring vertex _UpperCAmelCase = [] for vertex in range(len(_UpperCAmelCase ) ): distance_tv.append(sys.maxsize ) positions.append(_UpperCAmelCase ) heap.node_position.append(_UpperCAmelCase ) _UpperCAmelCase = [] _UpperCAmelCase = 1 _UpperCAmelCase = sys.maxsize for neighbor, distance in adjacency_list[0]: _UpperCAmelCase = 0 _UpperCAmelCase = distance heap.heapify(_UpperCAmelCase , _UpperCAmelCase ) for _ in range(1 , len(_UpperCAmelCase ) ): _UpperCAmelCase = heap.delete_minimum(_UpperCAmelCase , _UpperCAmelCase ) if visited[vertex] == 0: tree_edges.append((nbr_tv[vertex], vertex) ) _UpperCAmelCase = 1 for neighbor, distance in adjacency_list[vertex]: if ( visited[neighbor] == 0 and distance < distance_tv[heap.get_position(_UpperCAmelCase )] ): _UpperCAmelCase = distance heap.bottom_to_top( _UpperCAmelCase , heap.get_position(_UpperCAmelCase ) , _UpperCAmelCase , _UpperCAmelCase ) _UpperCAmelCase = vertex return tree_edges if __name__ == "__main__": # pragma: no cover # < --------- Prims Algorithm --------- > UpperCAmelCase__ = int(input("Enter number of edges: ").strip()) UpperCAmelCase__ = defaultdict(list) for _ in range(edges_number): UpperCAmelCase__ = [int(x) for x in input().strip().split()] adjacency_list[edge[0]].append([edge[1], edge[2]]) adjacency_list[edge[1]].append([edge[0], edge[2]]) print(prisms_algorithm(adjacency_list))
339
1
from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxSeqaSeqConfigWithPast from ...utils import logging UpperCAmelCase__ = logging.get_logger(__name__) UpperCAmelCase__ = { "t5-small": "https://huggingface.co/t5-small/resolve/main/config.json", "t5-base": "https://huggingface.co/t5-base/resolve/main/config.json", "t5-large": "https://huggingface.co/t5-large/resolve/main/config.json", "t5-3b": "https://huggingface.co/t5-3b/resolve/main/config.json", "t5-11b": "https://huggingface.co/t5-11b/resolve/main/config.json", } class __lowerCAmelCase ( A ): UpperCamelCase = '''t5''' UpperCamelCase = ['''past_key_values'''] UpperCamelCase = {'''hidden_size''': '''d_model''', '''num_attention_heads''': '''num_heads''', '''num_hidden_layers''': '''num_layers'''} def __init__( self : Optional[Any] , A : Union[str, Any]=3_21_28 , A : Optional[Any]=5_12 , A : Optional[Any]=64 , A : Union[str, Any]=20_48 , A : Tuple=6 , A : Optional[int]=None , A : List[Any]=8 , A : Dict=32 , A : str=1_28 , A : Tuple=0.1 , A : List[str]=1E-6 , A : str=1.0 , A : Optional[Any]="relu" , A : Tuple=True , A : Optional[int]=True , A : Optional[Any]=0 , A : Optional[Any]=1 , **A : Dict , ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = vocab_size _UpperCAmelCase = d_model _UpperCAmelCase = d_kv _UpperCAmelCase = d_ff _UpperCAmelCase = num_layers _UpperCAmelCase = ( num_decoder_layers if num_decoder_layers is not None else self.num_layers ) # default = symmetry _UpperCAmelCase = num_heads _UpperCAmelCase = relative_attention_num_buckets _UpperCAmelCase = relative_attention_max_distance _UpperCAmelCase = dropout_rate _UpperCAmelCase = layer_norm_epsilon _UpperCAmelCase = initializer_factor _UpperCAmelCase = feed_forward_proj _UpperCAmelCase = use_cache _UpperCAmelCase = self.feed_forward_proj.split('-') _UpperCAmelCase = act_info[-1] _UpperCAmelCase = act_info[0] == 'gated' if len(A) > 1 and act_info[0] != "gated" or len(A) > 2: raise ValueError( F"`feed_forward_proj`: {feed_forward_proj} is not a valid activation function of the dense layer." 'Please make sure `feed_forward_proj` is of the format `gated-{ACT_FN}` or `{ACT_FN}`, e.g. ' '\'gated-gelu\' or \'relu\'') # for backwards compatibility if feed_forward_proj == "gated-gelu": _UpperCAmelCase = 'gelu_new' super().__init__( pad_token_id=A , eos_token_id=A , is_encoder_decoder=A , **A , ) class __lowerCAmelCase ( A ): @property def _lowerCamelCase ( self : List[str]) -> Mapping[str, Mapping[int, str]]: """simple docstring""" _UpperCAmelCase = { 'input_ids': {0: 'batch', 1: 'encoder_sequence'}, 'attention_mask': {0: 'batch', 1: 'encoder_sequence'}, } if self.use_past: _UpperCAmelCase = 'past_encoder_sequence + sequence' _UpperCAmelCase = {0: 'batch'} _UpperCAmelCase = {0: 'batch', 1: 'past_decoder_sequence + sequence'} else: _UpperCAmelCase = {0: 'batch', 1: 'decoder_sequence'} _UpperCAmelCase = {0: 'batch', 1: 'decoder_sequence'} if self.use_past: self.fill_with_past_key_values_(A , direction='inputs') return common_inputs @property def _lowerCamelCase ( self : Any) -> int: """simple docstring""" return 13
339
import torch from transformers import CamembertForMaskedLM, CamembertTokenizer def A ( _UpperCAmelCase : str , _UpperCAmelCase : Any , _UpperCAmelCase : List[str] , _UpperCAmelCase : Optional[int]=5 ) -> List[Any]: '''simple docstring''' # Adapted from https://github.com/pytorch/fairseq/blob/master/fairseq/models/roberta/hub_interface.py assert masked_input.count('<mask>' ) == 1 _UpperCAmelCase = torch.tensor(tokenizer.encode(_UpperCAmelCase , add_special_tokens=_UpperCAmelCase ) ).unsqueeze(0 ) # Batch size 1 _UpperCAmelCase = model(_UpperCAmelCase )[0] # The last hidden-state is the first element of the output tuple _UpperCAmelCase = (input_ids.squeeze() == tokenizer.mask_token_id).nonzero().item() _UpperCAmelCase = logits[0, masked_index, :] _UpperCAmelCase = logits.softmax(dim=0 ) _UpperCAmelCase , _UpperCAmelCase = prob.topk(k=_UpperCAmelCase , dim=0 ) _UpperCAmelCase = ' '.join( [tokenizer.convert_ids_to_tokens(indices[i].item() ) for i in range(len(_UpperCAmelCase ) )] ) _UpperCAmelCase = tokenizer.mask_token _UpperCAmelCase = [] for index, predicted_token_bpe in enumerate(topk_predicted_token_bpe.split(' ' ) ): _UpperCAmelCase = predicted_token_bpe.replace('\u2581' , ' ' ) if " {0}".format(_UpperCAmelCase ) in masked_input: topk_filled_outputs.append( ( masked_input.replace(' {0}'.format(_UpperCAmelCase ) , _UpperCAmelCase ), values[index].item(), predicted_token, ) ) else: topk_filled_outputs.append( ( masked_input.replace(_UpperCAmelCase , _UpperCAmelCase ), values[index].item(), predicted_token, ) ) return topk_filled_outputs UpperCAmelCase__ = CamembertTokenizer.from_pretrained("camembert-base") UpperCAmelCase__ = CamembertForMaskedLM.from_pretrained("camembert-base") model.eval() UpperCAmelCase__ = "Le camembert est <mask> :)" print(fill_mask(masked_input, model, tokenizer, topk=3))
339
1
# This code is adapted from OpenAI's release # https://github.com/openai/human-eval/blob/master/human_eval/execution.py import contextlib import faulthandler import io import multiprocessing import os import platform import signal import tempfile def A ( _UpperCAmelCase : Union[str, Any] , _UpperCAmelCase : Dict , _UpperCAmelCase : Dict , _UpperCAmelCase : Dict ) -> Any: '''simple docstring''' _UpperCAmelCase = multiprocessing.Manager() _UpperCAmelCase = manager.list() _UpperCAmelCase = multiprocessing.Process(target=_UpperCAmelCase , args=(check_program, result, timeout) ) p.start() p.join(timeout=timeout + 1 ) if p.is_alive(): p.kill() if not result: result.append('timed out' ) return { "task_id": task_id, "passed": result[0] == "passed", "result": result[0], "completion_id": completion_id, } def A ( _UpperCAmelCase : str , _UpperCAmelCase : List[str] , _UpperCAmelCase : Dict ) -> Optional[int]: '''simple docstring''' with create_tempdir(): # These system calls are needed when cleaning up tempdir. import os import shutil _UpperCAmelCase = shutil.rmtree _UpperCAmelCase = os.rmdir _UpperCAmelCase = os.chdir # Disable functionalities that can make destructive changes to the test. reliability_guard() # Run program. try: _UpperCAmelCase = {} with swallow_io(): with time_limit(_UpperCAmelCase ): exec(_UpperCAmelCase , _UpperCAmelCase ) result.append('passed' ) except TimeoutException: result.append('timed out' ) except BaseException as e: result.append(F"failed: {e}" ) # Needed for cleaning up. _UpperCAmelCase = rmtree _UpperCAmelCase = rmdir _UpperCAmelCase = chdir @contextlib.contextmanager def A ( _UpperCAmelCase : Union[str, Any] ) -> Any: '''simple docstring''' def signal_handler(_UpperCAmelCase : List[Any] , _UpperCAmelCase : Dict ): raise TimeoutException('Timed out!' ) signal.setitimer(signal.ITIMER_REAL , _UpperCAmelCase ) signal.signal(signal.SIGALRM , _UpperCAmelCase ) try: yield finally: signal.setitimer(signal.ITIMER_REAL , 0 ) @contextlib.contextmanager def A ( ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = WriteOnlyStringIO() with contextlib.redirect_stdout(_UpperCAmelCase ): with contextlib.redirect_stderr(_UpperCAmelCase ): with redirect_stdin(_UpperCAmelCase ): yield @contextlib.contextmanager def A ( ) -> Any: '''simple docstring''' with tempfile.TemporaryDirectory() as dirname: with chdir(_UpperCAmelCase ): yield dirname class __lowerCAmelCase ( A ): pass class __lowerCAmelCase ( io.StringIO ): def _lowerCamelCase ( self : Tuple , *A : str , **A : Any) -> Any: """simple docstring""" raise OSError def _lowerCamelCase ( self : List[str] , *A : Optional[Any] , **A : Optional[Any]) -> Optional[int]: """simple docstring""" raise OSError def _lowerCamelCase ( self : str , *A : List[str] , **A : List[Any]) -> Union[str, Any]: """simple docstring""" raise OSError def _lowerCamelCase ( self : Union[str, Any] , *A : Optional[Any] , **A : List[str]) -> Optional[int]: """simple docstring""" return False class __lowerCAmelCase ( contextlib._RedirectStream ): # type: ignore UpperCamelCase = '''stdin''' @contextlib.contextmanager def A ( _UpperCAmelCase : List[Any] ) -> Dict: '''simple docstring''' if root == ".": yield return _UpperCAmelCase = os.getcwd() os.chdir(_UpperCAmelCase ) try: yield except BaseException as exc: raise exc finally: os.chdir(_UpperCAmelCase ) def A ( _UpperCAmelCase : List[str]=None ) -> Any: '''simple docstring''' if maximum_memory_bytes is not None: import resource resource.setrlimit(resource.RLIMIT_AS , (maximum_memory_bytes, maximum_memory_bytes) ) resource.setrlimit(resource.RLIMIT_DATA , (maximum_memory_bytes, maximum_memory_bytes) ) if not platform.uname().system == "Darwin": resource.setrlimit(resource.RLIMIT_STACK , (maximum_memory_bytes, maximum_memory_bytes) ) faulthandler.disable() import builtins _UpperCAmelCase = None _UpperCAmelCase = None import os _UpperCAmelCase = '1' _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None import shutil _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None import subprocess _UpperCAmelCase = None # type: ignore _UpperCAmelCase = None import sys _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None
339
import math import unittest def A ( _UpperCAmelCase : int ) -> bool: '''simple docstring''' assert isinstance(_UpperCAmelCase , _UpperCAmelCase ) and ( number >= 0 ), "'number' must been an int and positive" if 1 < number < 4: # 2 and 3 are primes return True elif number < 2 or number % 2 == 0 or number % 3 == 0: # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes return False # All primes number are in format of 6k +/- 1 for i in range(5 , int(math.sqrt(_UpperCAmelCase ) + 1 ) , 6 ): if number % i == 0 or number % (i + 2) == 0: return False return True class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Tuple) -> Union[str, Any]: """simple docstring""" self.assertTrue(is_prime(2)) self.assertTrue(is_prime(3)) self.assertTrue(is_prime(5)) self.assertTrue(is_prime(7)) self.assertTrue(is_prime(11)) self.assertTrue(is_prime(13)) self.assertTrue(is_prime(17)) self.assertTrue(is_prime(19)) self.assertTrue(is_prime(23)) self.assertTrue(is_prime(29)) def _lowerCamelCase ( self : Optional[int]) -> Any: """simple docstring""" with self.assertRaises(A): is_prime(-19) self.assertFalse( is_prime(0) , 'Zero doesn\'t have any positive factors, primes must have exactly two.' , ) self.assertFalse( is_prime(1) , 'One only has 1 positive factor, primes must have exactly two.' , ) self.assertFalse(is_prime(2 * 2)) self.assertFalse(is_prime(2 * 3)) self.assertFalse(is_prime(3 * 3)) self.assertFalse(is_prime(3 * 5)) self.assertFalse(is_prime(3 * 5 * 7)) if __name__ == "__main__": unittest.main()
339
1
import unittest from diffusers import FlaxAutoencoderKL from diffusers.utils import is_flax_available from diffusers.utils.testing_utils import require_flax from .test_modeling_common_flax import FlaxModelTesterMixin if is_flax_available(): import jax @require_flax class __lowerCAmelCase ( A , unittest.TestCase ): UpperCamelCase = FlaxAutoencoderKL @property def _lowerCamelCase ( self : str) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = 4 _UpperCAmelCase = 3 _UpperCAmelCase = (32, 32) _UpperCAmelCase = jax.random.PRNGKey(0) _UpperCAmelCase = jax.random.uniform(A , ((batch_size, num_channels) + sizes)) return {"sample": image, "prng_key": prng_key} def _lowerCamelCase ( self : Optional[Any]) -> Dict: """simple docstring""" _UpperCAmelCase = { 'block_out_channels': [32, 64], 'in_channels': 3, 'out_channels': 3, 'down_block_types': ['DownEncoderBlock2D', 'DownEncoderBlock2D'], 'up_block_types': ['UpDecoderBlock2D', 'UpDecoderBlock2D'], 'latent_channels': 4, } _UpperCAmelCase = self.dummy_input return init_dict, inputs_dict
339
from typing import Dict, List from nltk.translate import gleu_score import datasets from datasets import MetricInfo UpperCAmelCase__ = "\\n@misc{wu2016googles,\n title={Google's Neural Machine Translation System: Bridging the Gap between Human and Machine Translation},\n author={Yonghui Wu and Mike Schuster and Zhifeng Chen and Quoc V. Le and Mohammad Norouzi and Wolfgang Macherey\n and Maxim Krikun and Yuan Cao and Qin Gao and Klaus Macherey and Jeff Klingner and Apurva Shah and Melvin\n Johnson and Xiaobing Liu and Łukasz Kaiser and Stephan Gouws and Yoshikiyo Kato and Taku Kudo and Hideto\n Kazawa and Keith Stevens and George Kurian and Nishant Patil and Wei Wang and Cliff Young and\n Jason Smith and Jason Riesa and Alex Rudnick and Oriol Vinyals and Greg Corrado and Macduff Hughes\n and Jeffrey Dean},\n year={2016},\n eprint={1609.08144},\n archivePrefix={arXiv},\n primaryClass={cs.CL}\n}\n" UpperCAmelCase__ = "\\nThe BLEU score has some undesirable properties when used for single\nsentences, as it was designed to be a corpus measure. We therefore\nuse a slightly different score for our RL experiments which we call\nthe 'GLEU score'. For the GLEU score, we record all sub-sequences of\n1, 2, 3 or 4 tokens in output and target sequence (n-grams). We then\ncompute a recall, which is the ratio of the number of matching n-grams\nto the number of total n-grams in the target (ground truth) sequence,\nand a precision, which is the ratio of the number of matching n-grams\nto the number of total n-grams in the generated output sequence. Then\nGLEU score is simply the minimum of recall and precision. This GLEU\nscore's range is always between 0 (no matches) and 1 (all match) and\nit is symmetrical when switching output and target. According to\nour experiments, GLEU score correlates quite well with the BLEU\nmetric on a corpus level but does not have its drawbacks for our per\nsentence reward objective.\n" UpperCAmelCase__ = "\\nComputes corpus-level Google BLEU (GLEU) score of translated segments against one or more references.\nInstead of averaging the sentence level GLEU scores (i.e. macro-average precision), Wu et al. (2016) sum up the matching\ntokens and the max of hypothesis and reference tokens for each sentence, then compute using the aggregate values.\n\nArgs:\n predictions (list of str): list of translations to score.\n Each translation should be tokenized into a list of tokens.\n references (list of list of str): list of lists of references for each translation.\n Each reference should be tokenized into a list of tokens.\n min_len (int): The minimum order of n-gram this function should extract. Defaults to 1.\n max_len (int): The maximum order of n-gram this function should extract. Defaults to 4.\n\nReturns:\n 'google_bleu': google_bleu score\n\nExamples:\n Example 1:\n >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'always',\n ... 'disobeys', 'the', 'commands', 'of', 'the', 'cat']\n >>> ref1a = ['It', 'is', 'the', 'guiding', 'principle', 'which',\n ... 'guarantees', 'the', 'rubber', 'duck', 'forces', 'never',\n ... 'being', 'under', 'the', 'command', 'of', 'the', 'cat']\n\n >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was',\n ... 'interested', 'in', 'world', 'history']\n >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history',\n ... 'because', 'he', 'read', 'the', 'book']\n\n >>> list_of_references = [[ref1a], [ref2a]]\n >>> hypotheses = [hyp1, hyp2]\n >>> google_bleu = datasets.load_metric(\"google_bleu\")\n >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references)\n >>> print(round(results[\"google_bleu\"], 2))\n 0.44\n\n Example 2:\n >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'always',\n ... 'disobeys', 'the', 'commands', 'of', 'the', 'cat']\n >>> ref1a = ['It', 'is', 'the', 'guiding', 'principle', 'which',\n ... 'guarantees', 'the', 'rubber', 'duck', 'forces', 'never',\n ... 'being', 'under', 'the', 'command', 'of', 'the', 'cat']\n >>> ref1b = ['It', 'is', 'a', 'guide', 'to', 'action', 'that',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'will', 'never',\n ... 'heed', 'the', 'cat', 'commands']\n >>> ref1c = ['It', 'is', 'the', 'practical', 'guide', 'for', 'the',\n ... 'rubber', 'duck', 'army', 'never', 'to', 'heed', 'the', 'directions',\n ... 'of', 'the', 'cat']\n\n >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was',\n ... 'interested', 'in', 'world', 'history']\n >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history',\n ... 'because', 'he', 'read', 'the', 'book']\n\n >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]\n >>> hypotheses = [hyp1, hyp2]\n >>> google_bleu = datasets.load_metric(\"google_bleu\")\n >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references)\n >>> print(round(results[\"google_bleu\"], 2))\n 0.61\n\n Example 3:\n >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'always',\n ... 'disobeys', 'the', 'commands', 'of', 'the', 'cat']\n >>> ref1a = ['It', 'is', 'the', 'guiding', 'principle', 'which',\n ... 'guarantees', 'the', 'rubber', 'duck', 'forces', 'never',\n ... 'being', 'under', 'the', 'command', 'of', 'the', 'cat']\n >>> ref1b = ['It', 'is', 'a', 'guide', 'to', 'action', 'that',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'will', 'never',\n ... 'heed', 'the', 'cat', 'commands']\n >>> ref1c = ['It', 'is', 'the', 'practical', 'guide', 'for', 'the',\n ... 'rubber', 'duck', 'army', 'never', 'to', 'heed', 'the', 'directions',\n ... 'of', 'the', 'cat']\n\n >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was',\n ... 'interested', 'in', 'world', 'history']\n >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history',\n ... 'because', 'he', 'read', 'the', 'book']\n\n >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]\n >>> hypotheses = [hyp1, hyp2]\n >>> google_bleu = datasets.load_metric(\"google_bleu\")\n >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references, min_len=2)\n >>> print(round(results[\"google_bleu\"], 2))\n 0.53\n\n Example 4:\n >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'always',\n ... 'disobeys', 'the', 'commands', 'of', 'the', 'cat']\n >>> ref1a = ['It', 'is', 'the', 'guiding', 'principle', 'which',\n ... 'guarantees', 'the', 'rubber', 'duck', 'forces', 'never',\n ... 'being', 'under', 'the', 'command', 'of', 'the', 'cat']\n >>> ref1b = ['It', 'is', 'a', 'guide', 'to', 'action', 'that',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'will', 'never',\n ... 'heed', 'the', 'cat', 'commands']\n >>> ref1c = ['It', 'is', 'the', 'practical', 'guide', 'for', 'the',\n ... 'rubber', 'duck', 'army', 'never', 'to', 'heed', 'the', 'directions',\n ... 'of', 'the', 'cat']\n\n >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was',\n ... 'interested', 'in', 'world', 'history']\n >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history',\n ... 'because', 'he', 'read', 'the', 'book']\n\n >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]\n >>> hypotheses = [hyp1, hyp2]\n >>> google_bleu = datasets.load_metric(\"google_bleu\")\n >>> results = google_bleu.compute(predictions=hypotheses,references=list_of_references, min_len=2, max_len=6)\n >>> print(round(results[\"google_bleu\"], 2))\n 0.4\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class __lowerCAmelCase ( datasets.Metric ): def _lowerCamelCase ( self : str) -> MetricInfo: """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': datasets.Sequence(datasets.Value('string' , id='token') , id='sequence'), 'references': datasets.Sequence( datasets.Sequence(datasets.Value('string' , id='token') , id='sequence') , id='references'), }) , ) def _lowerCamelCase ( self : Union[str, Any] , A : List[List[List[str]]] , A : List[List[str]] , A : int = 1 , A : int = 4 , ) -> Dict[str, float]: """simple docstring""" return { "google_bleu": gleu_score.corpus_gleu( list_of_references=A , hypotheses=A , min_len=A , max_len=A) }
339
1
import json import os import shutil import tempfile import unittest import numpy as np import pytest from transformers import BertTokenizer, BertTokenizerFast from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES from transformers.testing_utils import require_vision from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available if is_vision_available(): from PIL import Image from transformers import AlignProcessor, EfficientNetImageProcessor @require_vision class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : str) -> str: """simple docstring""" _UpperCAmelCase = tempfile.mkdtemp() _UpperCAmelCase = [ '[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing', ',', 'low', 'lowest', ] _UpperCAmelCase = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['vocab_file']) with open(self.vocab_file , 'w' , encoding='utf-8') as vocab_writer: vocab_writer.write(''.join([x + '\n' for x in vocab_tokens])) _UpperCAmelCase = { 'do_resize': True, 'size': 20, 'do_center_crop': True, 'crop_size': 18, 'do_normalize': True, 'image_mean': [0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3], 'image_std': [0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1], } _UpperCAmelCase = os.path.join(self.tmpdirname , A) with open(self.image_processor_file , 'w' , encoding='utf-8') as fp: json.dump(A , A) def _lowerCamelCase ( self : List[str] , **A : Optional[int]) -> Union[str, Any]: """simple docstring""" return BertTokenizer.from_pretrained(self.tmpdirname , **A) def _lowerCamelCase ( self : Optional[Any] , **A : str) -> List[str]: """simple docstring""" return BertTokenizerFast.from_pretrained(self.tmpdirname , **A) def _lowerCamelCase ( self : List[str] , **A : Union[str, Any]) -> str: """simple docstring""" return EfficientNetImageProcessor.from_pretrained(self.tmpdirname , **A) def _lowerCamelCase ( self : Tuple) -> str: """simple docstring""" shutil.rmtree(self.tmpdirname) def _lowerCamelCase ( self : int) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = [np.random.randint(2_55 , size=(3, 30, 4_00) , dtype=np.uinta)] _UpperCAmelCase = [Image.fromarray(np.moveaxis(A , 0 , -1)) for x in image_inputs] return image_inputs def _lowerCamelCase ( self : Union[str, Any]) -> Optional[int]: """simple docstring""" _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = self.get_rust_tokenizer() _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = AlignProcessor(tokenizer=A , image_processor=A) processor_slow.save_pretrained(self.tmpdirname) _UpperCAmelCase = AlignProcessor.from_pretrained(self.tmpdirname , use_fast=A) _UpperCAmelCase = AlignProcessor(tokenizer=A , image_processor=A) processor_fast.save_pretrained(self.tmpdirname) _UpperCAmelCase = AlignProcessor.from_pretrained(self.tmpdirname) self.assertEqual(processor_slow.tokenizer.get_vocab() , tokenizer_slow.get_vocab()) self.assertEqual(processor_fast.tokenizer.get_vocab() , tokenizer_fast.get_vocab()) self.assertEqual(tokenizer_slow.get_vocab() , tokenizer_fast.get_vocab()) self.assertIsInstance(processor_slow.tokenizer , A) self.assertIsInstance(processor_fast.tokenizer , A) self.assertEqual(processor_slow.image_processor.to_json_string() , image_processor.to_json_string()) self.assertEqual(processor_fast.image_processor.to_json_string() , image_processor.to_json_string()) self.assertIsInstance(processor_slow.image_processor , A) self.assertIsInstance(processor_fast.image_processor , A) def _lowerCamelCase ( self : List[Any]) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = AlignProcessor(tokenizer=self.get_tokenizer() , image_processor=self.get_image_processor()) processor.save_pretrained(self.tmpdirname) _UpperCAmelCase = self.get_tokenizer(bos_token='(BOS)' , eos_token='(EOS)') _UpperCAmelCase = self.get_image_processor(do_normalize=A , padding_value=1.0) _UpperCAmelCase = AlignProcessor.from_pretrained( self.tmpdirname , bos_token='(BOS)' , eos_token='(EOS)' , do_normalize=A , padding_value=1.0) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab()) self.assertIsInstance(processor.tokenizer , A) self.assertEqual(processor.image_processor.to_json_string() , image_processor_add_kwargs.to_json_string()) self.assertIsInstance(processor.image_processor , A) def _lowerCamelCase ( self : Optional[Any]) -> Dict: """simple docstring""" _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = AlignProcessor(tokenizer=A , image_processor=A) _UpperCAmelCase = self.prepare_image_inputs() _UpperCAmelCase = image_processor(A , return_tensors='np') _UpperCAmelCase = processor(images=A , return_tensors='np') for key in input_image_proc.keys(): self.assertAlmostEqual(input_image_proc[key].sum() , input_processor[key].sum() , delta=1E-2) def _lowerCamelCase ( self : List[Any]) -> Dict: """simple docstring""" _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = AlignProcessor(tokenizer=A , image_processor=A) _UpperCAmelCase = 'lower newer' _UpperCAmelCase = processor(text=A) _UpperCAmelCase = tokenizer(A , padding='max_length' , max_length=64) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key]) def _lowerCamelCase ( self : Any) -> Tuple: """simple docstring""" _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = AlignProcessor(tokenizer=A , image_processor=A) _UpperCAmelCase = 'lower newer' _UpperCAmelCase = self.prepare_image_inputs() _UpperCAmelCase = processor(text=A , images=A) self.assertListEqual(list(inputs.keys()) , ['input_ids', 'token_type_ids', 'attention_mask', 'pixel_values']) # test if it raises when no input is passed with pytest.raises(A): processor() def _lowerCamelCase ( self : Union[str, Any]) -> List[str]: """simple docstring""" _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = AlignProcessor(tokenizer=A , image_processor=A) _UpperCAmelCase = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] _UpperCAmelCase = processor.batch_decode(A) _UpperCAmelCase = tokenizer.batch_decode(A) self.assertListEqual(A , A) def _lowerCamelCase ( self : Dict) -> str: """simple docstring""" _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = AlignProcessor(tokenizer=A , image_processor=A) _UpperCAmelCase = 'lower newer' _UpperCAmelCase = self.prepare_image_inputs() _UpperCAmelCase = processor(text=A , images=A) self.assertListEqual(list(inputs.keys()) , processor.model_input_names)
339
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_sentencepiece_available, is_tf_available, is_tokenizers_available, is_torch_available, ) if is_sentencepiece_available(): from ..ta.tokenization_ta import TaTokenizer else: from ...utils.dummy_sentencepiece_objects import TaTokenizer UpperCAmelCase__ = TaTokenizer if is_tokenizers_available(): from ..ta.tokenization_ta_fast import TaTokenizerFast else: from ...utils.dummy_tokenizers_objects import TaTokenizerFast UpperCAmelCase__ = TaTokenizerFast UpperCAmelCase__ = {"configuration_mt5": ["MT5Config", "MT5OnnxConfig"]} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase__ = [ "MT5EncoderModel", "MT5ForConditionalGeneration", "MT5ForQuestionAnswering", "MT5Model", "MT5PreTrainedModel", "MT5Stack", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase__ = ["TFMT5EncoderModel", "TFMT5ForConditionalGeneration", "TFMT5Model"] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase__ = ["FlaxMT5EncoderModel", "FlaxMT5ForConditionalGeneration", "FlaxMT5Model"] if TYPE_CHECKING: from .configuration_mta import MTaConfig, MTaOnnxConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_mta import ( MTaEncoderModel, MTaForConditionalGeneration, MTaForQuestionAnswering, MTaModel, MTaPreTrainedModel, MTaStack, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_mta import TFMTaEncoderModel, TFMTaForConditionalGeneration, TFMTaModel try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_mta import FlaxMTaEncoderModel, FlaxMTaForConditionalGeneration, FlaxMTaModel else: import sys UpperCAmelCase__ = _LazyModule( __name__, globals()["__file__"], _import_structure, extra_objects={"MT5Tokenizer": MTaTokenizer, "MT5TokenizerFast": MTaTokenizerFast}, module_spec=__spec__, )
339
1
import gc import random import unittest import numpy as np import torch from transformers import CLIPImageProcessor, CLIPVisionConfig, CLIPVisionModel from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEImgaImgPipeline from diffusers.pipelines.shap_e import ShapERenderer from diffusers.utils import floats_tensor, load_image, load_numpy, slow from diffusers.utils.testing_utils import require_torch_gpu, torch_device from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference class __lowerCAmelCase ( A , unittest.TestCase ): UpperCamelCase = ShapEImgaImgPipeline UpperCamelCase = ['''image'''] UpperCamelCase = ['''image'''] UpperCamelCase = [ '''num_images_per_prompt''', '''num_inference_steps''', '''generator''', '''latents''', '''guidance_scale''', '''frame_size''', '''output_type''', '''return_dict''', ] UpperCamelCase = False @property def _lowerCamelCase ( self : Optional[Any]) -> Union[str, Any]: """simple docstring""" return 32 @property def _lowerCamelCase ( self : int) -> str: """simple docstring""" return 32 @property def _lowerCamelCase ( self : Union[str, Any]) -> str: """simple docstring""" return self.time_input_dim * 4 @property def _lowerCamelCase ( self : int) -> List[Any]: """simple docstring""" return 8 @property def _lowerCamelCase ( self : Dict) -> List[Any]: """simple docstring""" torch.manual_seed(0) _UpperCAmelCase = CLIPVisionConfig( hidden_size=self.text_embedder_hidden_size , image_size=64 , projection_dim=self.text_embedder_hidden_size , intermediate_size=37 , num_attention_heads=4 , num_channels=3 , num_hidden_layers=5 , patch_size=1 , ) _UpperCAmelCase = CLIPVisionModel(A) return model @property def _lowerCamelCase ( self : List[str]) -> List[str]: """simple docstring""" _UpperCAmelCase = CLIPImageProcessor( crop_size=2_24 , do_center_crop=A , do_normalize=A , do_resize=A , image_mean=[0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3] , image_std=[0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1] , resample=3 , size=2_24 , ) return image_processor @property def _lowerCamelCase ( self : List[Any]) -> Optional[int]: """simple docstring""" torch.manual_seed(0) _UpperCAmelCase = { 'num_attention_heads': 2, 'attention_head_dim': 16, 'embedding_dim': self.time_input_dim, 'num_embeddings': 32, 'embedding_proj_dim': self.text_embedder_hidden_size, 'time_embed_dim': self.time_embed_dim, 'num_layers': 1, 'clip_embed_dim': self.time_input_dim * 2, 'additional_embeddings': 0, 'time_embed_act_fn': 'gelu', 'norm_in_type': 'layer', 'embedding_proj_norm_type': 'layer', 'encoder_hid_proj_type': None, 'added_emb_type': None, } _UpperCAmelCase = PriorTransformer(**A) return model @property def _lowerCamelCase ( self : Tuple) -> Tuple: """simple docstring""" torch.manual_seed(0) _UpperCAmelCase = { 'param_shapes': ( (self.renderer_dim, 93), (self.renderer_dim, 8), (self.renderer_dim, 8), (self.renderer_dim, 8), ), 'd_latent': self.time_input_dim, 'd_hidden': self.renderer_dim, 'n_output': 12, 'background': ( 0.1, 0.1, 0.1, ), } _UpperCAmelCase = ShapERenderer(**A) return model def _lowerCamelCase ( self : Optional[Any]) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = self.dummy_prior _UpperCAmelCase = self.dummy_image_encoder _UpperCAmelCase = self.dummy_image_processor _UpperCAmelCase = self.dummy_renderer _UpperCAmelCase = HeunDiscreteScheduler( beta_schedule='exp' , num_train_timesteps=10_24 , prediction_type='sample' , use_karras_sigmas=A , clip_sample=A , clip_sample_range=1.0 , ) _UpperCAmelCase = { 'prior': prior, 'image_encoder': image_encoder, 'image_processor': image_processor, 'renderer': renderer, 'scheduler': scheduler, } return components def _lowerCamelCase ( self : int , A : Optional[Any] , A : List[str]=0) -> int: """simple docstring""" _UpperCAmelCase = floats_tensor((1, 3, 64, 64) , rng=random.Random(A)).to(A) if str(A).startswith('mps'): _UpperCAmelCase = torch.manual_seed(A) else: _UpperCAmelCase = torch.Generator(device=A).manual_seed(A) _UpperCAmelCase = { 'image': input_image, 'generator': generator, 'num_inference_steps': 1, 'frame_size': 32, 'output_type': 'np', } return inputs def _lowerCamelCase ( self : Tuple) -> Tuple: """simple docstring""" _UpperCAmelCase = 'cpu' _UpperCAmelCase = self.get_dummy_components() _UpperCAmelCase = self.pipeline_class(**A) _UpperCAmelCase = pipe.to(A) pipe.set_progress_bar_config(disable=A) _UpperCAmelCase = pipe(**self.get_dummy_inputs(A)) _UpperCAmelCase = output.images[0] _UpperCAmelCase = image[0, -3:, -3:, -1] assert image.shape == (20, 32, 32, 3) _UpperCAmelCase = np.array( [ 0.0_0_0_3_9_2_1_6, 0.0_0_0_3_9_2_1_6, 0.0_0_0_3_9_2_1_6, 0.0_0_0_3_9_2_1_6, 0.0_0_0_3_9_2_1_6, 0.0_0_0_3_9_2_1_6, 0.0_0_0_3_9_2_1_6, 0.0_0_0_3_9_2_1_6, 0.0_0_0_3_9_2_1_6, ]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2 def _lowerCamelCase ( self : Optional[int]) -> str: """simple docstring""" self._test_inference_batch_consistent(batch_sizes=[1, 2]) def _lowerCamelCase ( self : List[str]) -> Optional[int]: """simple docstring""" _UpperCAmelCase = torch_device == 'cpu' _UpperCAmelCase = True self._test_inference_batch_single_identical( batch_size=2 , test_max_difference=A , relax_max_difference=A , ) def _lowerCamelCase ( self : Tuple) -> List[Any]: """simple docstring""" _UpperCAmelCase = self.get_dummy_components() _UpperCAmelCase = self.pipeline_class(**A) _UpperCAmelCase = pipe.to(A) pipe.set_progress_bar_config(disable=A) _UpperCAmelCase = 1 _UpperCAmelCase = 2 _UpperCAmelCase = self.get_dummy_inputs(A) for key in inputs.keys(): if key in self.batch_params: _UpperCAmelCase = batch_size * [inputs[key]] _UpperCAmelCase = pipe(**A , num_images_per_prompt=A)[0] assert images.shape[0] == batch_size * num_images_per_prompt @slow @require_torch_gpu class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Union[str, Any]) -> Optional[int]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def _lowerCamelCase ( self : Dict) -> int: """simple docstring""" _UpperCAmelCase = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/shap_e/corgi.png') _UpperCAmelCase = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/shap_e/test_shap_e_img2img_out.npy') _UpperCAmelCase = ShapEImgaImgPipeline.from_pretrained('openai/shap-e-img2img') _UpperCAmelCase = pipe.to(A) pipe.set_progress_bar_config(disable=A) _UpperCAmelCase = torch.Generator(device=A).manual_seed(0) _UpperCAmelCase = pipe( A , generator=A , guidance_scale=3.0 , num_inference_steps=64 , frame_size=64 , output_type='np' , ).images[0] assert images.shape == (20, 64, 64, 3) assert_mean_pixel_difference(A , A)
339
from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCAmelCase__ = logging.get_logger(__name__) UpperCAmelCase__ = { "s-JoL/Open-Llama-V1": "https://huggingface.co/s-JoL/Open-Llama-V1/blob/main/config.json", } class __lowerCAmelCase ( A ): UpperCamelCase = '''open-llama''' def __init__( self : str , A : List[Any]=10_00_00 , A : Tuple=40_96 , A : Tuple=1_10_08 , A : List[str]=32 , A : Tuple=32 , A : Optional[Any]="silu" , A : int=20_48 , A : Optional[Any]=0.0_2 , A : Dict=1E-6 , A : Optional[Any]=True , A : List[Any]=0 , A : Dict=1 , A : int=2 , A : Dict=False , A : Optional[int]=True , A : List[Any]=0.1 , A : str=0.1 , A : Dict=True , A : Optional[Any]=True , A : Dict=None , **A : Union[str, Any] , ) -> Dict: """simple docstring""" _UpperCAmelCase = vocab_size _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = hidden_size _UpperCAmelCase = intermediate_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = hidden_act _UpperCAmelCase = initializer_range _UpperCAmelCase = rms_norm_eps _UpperCAmelCase = use_cache _UpperCAmelCase = kwargs.pop( 'use_memorry_efficient_attention' , A) _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_dropout_prob _UpperCAmelCase = use_stable_embedding _UpperCAmelCase = shared_input_output_embedding _UpperCAmelCase = rope_scaling self._rope_scaling_validation() super().__init__( pad_token_id=A , bos_token_id=A , eos_token_id=A , tie_word_embeddings=A , **A , ) def _lowerCamelCase ( self : List[str]) -> Union[str, Any]: """simple docstring""" if self.rope_scaling is None: return if not isinstance(self.rope_scaling , A) or len(self.rope_scaling) != 2: raise ValueError( '`rope_scaling` must be a dictionary with with two fields, `name` and `factor`, ' F"got {self.rope_scaling}") _UpperCAmelCase = self.rope_scaling.get('type' , A) _UpperCAmelCase = self.rope_scaling.get('factor' , A) if rope_scaling_type is None or rope_scaling_type not in ["linear", "dynamic"]: raise ValueError( F"`rope_scaling`'s name field must be one of ['linear', 'dynamic'], got {rope_scaling_type}") if rope_scaling_factor is None or not isinstance(A , A) or rope_scaling_factor <= 1.0: raise ValueError(F"`rope_scaling`'s factor field must be an float > 1, got {rope_scaling_factor}")
339
1
import json import os import shutil import tempfile import unittest import numpy as np import pytest from transformers import CLIPTokenizer, CLIPTokenizerFast from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES from transformers.testing_utils import require_vision from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available if is_vision_available(): from PIL import Image from transformers import CLIPSegProcessor, ViTImageProcessor @require_vision class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Optional[Any]) -> List[str]: """simple docstring""" _UpperCAmelCase = tempfile.mkdtemp() # fmt: off _UpperCAmelCase = ['l', 'o', 'w', 'e', 'r', 's', 't', 'i', 'd', 'n', 'lo', 'l</w>', 'w</w>', 'r</w>', 't</w>', 'low</w>', 'er</w>', 'lowest</w>', 'newer</w>', 'wider', '<unk>', '<|startoftext|>', '<|endoftext|>'] # fmt: on _UpperCAmelCase = dict(zip(A , range(len(A)))) _UpperCAmelCase = ['#version: 0.2', 'l o', 'lo w</w>', 'e r</w>', ''] _UpperCAmelCase = {'unk_token': '<unk>'} _UpperCAmelCase = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['vocab_file']) _UpperCAmelCase = 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(A) + '\n') with open(self.merges_file , 'w' , encoding='utf-8') as fp: fp.write('\n'.join(A)) _UpperCAmelCase = { 'do_resize': True, 'size': 20, 'do_center_crop': True, 'crop_size': 18, 'do_normalize': True, 'image_mean': [0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3], 'image_std': [0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1], } _UpperCAmelCase = os.path.join(self.tmpdirname , A) with open(self.image_processor_file , 'w' , encoding='utf-8') as fp: json.dump(A , A) def _lowerCamelCase ( self : str , **A : Optional[int]) -> Any: """simple docstring""" return CLIPTokenizer.from_pretrained(self.tmpdirname , **A) def _lowerCamelCase ( self : Dict , **A : int) -> str: """simple docstring""" return CLIPTokenizerFast.from_pretrained(self.tmpdirname , **A) def _lowerCamelCase ( self : Any , **A : Any) -> int: """simple docstring""" return ViTImageProcessor.from_pretrained(self.tmpdirname , **A) def _lowerCamelCase ( self : str) -> int: """simple docstring""" shutil.rmtree(self.tmpdirname) def _lowerCamelCase ( self : int) -> List[Any]: """simple docstring""" _UpperCAmelCase = [np.random.randint(2_55 , size=(3, 30, 4_00) , dtype=np.uinta)] _UpperCAmelCase = [Image.fromarray(np.moveaxis(A , 0 , -1)) for x in image_inputs] return image_inputs def _lowerCamelCase ( self : List[str]) -> int: """simple docstring""" _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = self.get_rust_tokenizer() _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = CLIPSegProcessor(tokenizer=A , image_processor=A) processor_slow.save_pretrained(self.tmpdirname) _UpperCAmelCase = CLIPSegProcessor.from_pretrained(self.tmpdirname , use_fast=A) _UpperCAmelCase = CLIPSegProcessor(tokenizer=A , image_processor=A) processor_fast.save_pretrained(self.tmpdirname) _UpperCAmelCase = CLIPSegProcessor.from_pretrained(self.tmpdirname) self.assertEqual(processor_slow.tokenizer.get_vocab() , tokenizer_slow.get_vocab()) self.assertEqual(processor_fast.tokenizer.get_vocab() , tokenizer_fast.get_vocab()) self.assertEqual(tokenizer_slow.get_vocab() , tokenizer_fast.get_vocab()) self.assertIsInstance(processor_slow.tokenizer , A) self.assertIsInstance(processor_fast.tokenizer , A) self.assertEqual(processor_slow.image_processor.to_json_string() , image_processor.to_json_string()) self.assertEqual(processor_fast.image_processor.to_json_string() , image_processor.to_json_string()) self.assertIsInstance(processor_slow.image_processor , A) self.assertIsInstance(processor_fast.image_processor , A) def _lowerCamelCase ( self : Optional[int]) -> int: """simple docstring""" _UpperCAmelCase = CLIPSegProcessor(tokenizer=self.get_tokenizer() , image_processor=self.get_image_processor()) processor.save_pretrained(self.tmpdirname) _UpperCAmelCase = self.get_tokenizer(bos_token='(BOS)' , eos_token='(EOS)') _UpperCAmelCase = self.get_image_processor(do_normalize=A , padding_value=1.0) _UpperCAmelCase = CLIPSegProcessor.from_pretrained( self.tmpdirname , bos_token='(BOS)' , eos_token='(EOS)' , do_normalize=A , padding_value=1.0) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab()) self.assertIsInstance(processor.tokenizer , A) self.assertEqual(processor.image_processor.to_json_string() , image_processor_add_kwargs.to_json_string()) self.assertIsInstance(processor.image_processor , A) def _lowerCamelCase ( self : str) -> List[Any]: """simple docstring""" _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = CLIPSegProcessor(tokenizer=A , image_processor=A) _UpperCAmelCase = self.prepare_image_inputs() _UpperCAmelCase = image_processor(A , return_tensors='np') _UpperCAmelCase = processor(images=A , return_tensors='np') for key in input_feat_extract.keys(): self.assertAlmostEqual(input_feat_extract[key].sum() , input_processor[key].sum() , delta=1E-2) def _lowerCamelCase ( self : Union[str, Any]) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = CLIPSegProcessor(tokenizer=A , image_processor=A) _UpperCAmelCase = 'lower newer' _UpperCAmelCase = processor(text=A) _UpperCAmelCase = tokenizer(A) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key]) def _lowerCamelCase ( self : Tuple) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = CLIPSegProcessor(tokenizer=A , image_processor=A) _UpperCAmelCase = 'lower newer' _UpperCAmelCase = self.prepare_image_inputs() _UpperCAmelCase = processor(text=A , images=A) self.assertListEqual(list(inputs.keys()) , ['input_ids', 'attention_mask', 'pixel_values']) # test if it raises when no input is passed with pytest.raises(A): processor() def _lowerCamelCase ( self : Optional[int]) -> List[str]: """simple docstring""" _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = CLIPSegProcessor(tokenizer=A , image_processor=A) _UpperCAmelCase = self.prepare_image_inputs() _UpperCAmelCase = self.prepare_image_inputs() _UpperCAmelCase = processor(images=A , visual_prompt=A) self.assertListEqual(list(inputs.keys()) , ['pixel_values', 'conditional_pixel_values']) # test if it raises when no input is passed with pytest.raises(A): processor() def _lowerCamelCase ( self : Optional[int]) -> Dict: """simple docstring""" _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = CLIPSegProcessor(tokenizer=A , image_processor=A) _UpperCAmelCase = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] _UpperCAmelCase = processor.batch_decode(A) _UpperCAmelCase = tokenizer.batch_decode(A) self.assertListEqual(A , A)
339
def A ( _UpperCAmelCase : str ) -> bool: '''simple docstring''' return credit_card_number.startswith(('34', '35', '37', '4', '5', '6') ) def A ( _UpperCAmelCase : str ) -> bool: '''simple docstring''' _UpperCAmelCase = credit_card_number _UpperCAmelCase = 0 _UpperCAmelCase = len(_UpperCAmelCase ) - 2 for i in range(_UpperCAmelCase , -1 , -2 ): # double the value of every second digit _UpperCAmelCase = int(cc_number[i] ) digit *= 2 # If doubling of a number results in a two digit number # i.e greater than 9(e.g., 6 × 2 = 12), # then add the digits of the product (e.g., 12: 1 + 2 = 3, 15: 1 + 5 = 6), # to get a single digit number. if digit > 9: digit %= 10 digit += 1 _UpperCAmelCase = cc_number[:i] + str(_UpperCAmelCase ) + cc_number[i + 1 :] total += digit # Sum up the remaining digits for i in range(len(_UpperCAmelCase ) - 1 , -1 , -2 ): total += int(cc_number[i] ) return total % 10 == 0 def A ( _UpperCAmelCase : str ) -> bool: '''simple docstring''' _UpperCAmelCase = F"{credit_card_number} is an invalid credit card number because" if not credit_card_number.isdigit(): print(F"{error_message} it has nonnumerical characters." ) return False if not 13 <= len(_UpperCAmelCase ) <= 16: print(F"{error_message} of its length." ) return False if not validate_initial_digits(_UpperCAmelCase ): print(F"{error_message} of its first two digits." ) return False if not luhn_validation(_UpperCAmelCase ): print(F"{error_message} it fails the Luhn check." ) return False print(F"{credit_card_number} is a valid credit card number." ) return True if __name__ == "__main__": import doctest doctest.testmod() validate_credit_card_number("4111111111111111") validate_credit_card_number("32323")
339
1
from __future__ import annotations import inspect import unittest import numpy as np from transformers import ResNetConfig from transformers.testing_utils import require_tf, require_vision, slow from transformers.utils import cached_property, is_tf_available, is_vision_available from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import tensorflow as tf from transformers import TFResNetForImageClassification, TFResNetModel from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import AutoImageProcessor class __lowerCAmelCase : def __init__( self : Optional[int] , A : Tuple , A : str=3 , A : List[Any]=32 , A : List[str]=3 , A : Optional[int]=10 , A : int=[10, 20, 30, 40] , A : Union[str, Any]=[1, 1, 2, 1] , A : Tuple=True , A : Dict=True , A : Any="relu" , A : Optional[int]=3 , A : Union[str, Any]=None , ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = image_size _UpperCAmelCase = num_channels _UpperCAmelCase = embeddings_size _UpperCAmelCase = hidden_sizes _UpperCAmelCase = depths _UpperCAmelCase = is_training _UpperCAmelCase = use_labels _UpperCAmelCase = hidden_act _UpperCAmelCase = num_labels _UpperCAmelCase = scope _UpperCAmelCase = len(A) def _lowerCamelCase ( self : List[str]) -> Optional[int]: """simple docstring""" _UpperCAmelCase = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]) _UpperCAmelCase = None if self.use_labels: _UpperCAmelCase = ids_tensor([self.batch_size] , self.num_labels) _UpperCAmelCase = self.get_config() return config, pixel_values, labels def _lowerCamelCase ( self : List[Any]) -> Union[str, Any]: """simple docstring""" return ResNetConfig( num_channels=self.num_channels , embeddings_size=self.embeddings_size , hidden_sizes=self.hidden_sizes , depths=self.depths , hidden_act=self.hidden_act , num_labels=self.num_labels , image_size=self.image_size , ) def _lowerCamelCase ( self : Optional[Any] , A : Optional[int] , A : int , A : Tuple) -> List[str]: """simple docstring""" _UpperCAmelCase = TFResNetModel(config=A) _UpperCAmelCase = model(A) # expected last hidden states: B, C, H // 32, W // 32 self.parent.assertEqual( result.last_hidden_state.shape , (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32) , ) def _lowerCamelCase ( self : Optional[Any] , A : List[str] , A : List[str] , A : Tuple) -> Dict: """simple docstring""" _UpperCAmelCase = self.num_labels _UpperCAmelCase = TFResNetForImageClassification(A) _UpperCAmelCase = model(A , labels=A) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels)) def _lowerCamelCase ( self : Union[str, Any]) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = self.prepare_config_and_inputs() _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = config_and_inputs _UpperCAmelCase = {'pixel_values': pixel_values} return config, inputs_dict @require_tf class __lowerCAmelCase ( A , A , unittest.TestCase ): UpperCamelCase = (TFResNetModel, TFResNetForImageClassification) if is_tf_available() else () UpperCamelCase = ( {'''feature-extraction''': TFResNetModel, '''image-classification''': TFResNetForImageClassification} if is_tf_available() else {} ) UpperCamelCase = False UpperCamelCase = False UpperCamelCase = False UpperCamelCase = False UpperCamelCase = False def _lowerCamelCase ( self : Optional[Any]) -> Optional[int]: """simple docstring""" _UpperCAmelCase = TFResNetModelTester(self) _UpperCAmelCase = ConfigTester(self , config_class=A , has_text_modality=A) def _lowerCamelCase ( self : int) -> Any: """simple docstring""" self.create_and_test_config_common_properties() self.config_tester.create_and_test_config_to_json_string() self.config_tester.create_and_test_config_to_json_file() self.config_tester.create_and_test_config_from_and_save_pretrained() self.config_tester.create_and_test_config_with_num_labels() self.config_tester.check_config_can_be_init_without_params() self.config_tester.check_config_arguments_init() def _lowerCamelCase ( self : Tuple) -> int: """simple docstring""" return @unittest.skip(reason='ResNet does not use inputs_embeds') def _lowerCamelCase ( self : Optional[Any]) -> Optional[Any]: """simple docstring""" pass @unittest.skip(reason='ResNet does not support input and output embeddings') def _lowerCamelCase ( self : Tuple) -> List[Any]: """simple docstring""" pass def _lowerCamelCase ( self : str) -> List[str]: """simple docstring""" _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(A) _UpperCAmelCase = inspect.signature(model.call) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCAmelCase = [*signature.parameters.keys()] _UpperCAmelCase = ['pixel_values'] self.assertListEqual(arg_names[:1] , A) def _lowerCamelCase ( self : Optional[Any]) -> Optional[int]: """simple docstring""" _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*A) def _lowerCamelCase ( self : int) -> str: """simple docstring""" def check_hidden_states_output(A : int , A : Union[str, Any] , A : str): _UpperCAmelCase = model_class(A) _UpperCAmelCase = model(**self._prepare_for_class(A , A)) _UpperCAmelCase = outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states _UpperCAmelCase = self.model_tester.num_stages self.assertEqual(len(A) , expected_num_stages + 1) # ResNet's feature maps are of shape (batch_size, num_channels, height, width) self.assertListEqual( list(hidden_states[0].shape[-2:]) , [self.model_tester.image_size // 4, self.model_tester.image_size // 4] , ) _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = ['basic', 'bottleneck'] for model_class in self.all_model_classes: for layer_type in layers_type: _UpperCAmelCase = layer_type _UpperCAmelCase = True check_hidden_states_output(A , A , A) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] _UpperCAmelCase = True check_hidden_states_output(A , A , A) def _lowerCamelCase ( self : str) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*A) @slow def _lowerCamelCase ( self : Any) -> Any: """simple docstring""" for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _UpperCAmelCase = TFResNetModel.from_pretrained(A) self.assertIsNotNone(A) def A ( ) -> List[str]: '''simple docstring''' _UpperCAmelCase = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' ) return image @require_tf @require_vision class __lowerCAmelCase ( unittest.TestCase ): @cached_property def _lowerCamelCase ( self : Tuple) -> List[str]: """simple docstring""" return ( AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]) if is_vision_available() else None ) @slow def _lowerCamelCase ( self : Union[str, Any]) -> Dict: """simple docstring""" _UpperCAmelCase = TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(images=A , return_tensors='tf') # forward pass _UpperCAmelCase = model(**A) # verify the logits _UpperCAmelCase = tf.TensorShape((1, 10_00)) self.assertEqual(outputs.logits.shape , A) _UpperCAmelCase = tf.constant([-1_1.1_0_6_9, -9.7_8_7_7, -8.3_7_7_7]) self.assertTrue(np.allclose(outputs.logits[0, :3].numpy() , A , atol=1E-4))
339
from functools import reduce UpperCAmelCase__ = ( "73167176531330624919225119674426574742355349194934" "96983520312774506326239578318016984801869478851843" "85861560789112949495459501737958331952853208805511" "12540698747158523863050715693290963295227443043557" "66896648950445244523161731856403098711121722383113" "62229893423380308135336276614282806444486645238749" "30358907296290491560440772390713810515859307960866" "70172427121883998797908792274921901699720888093776" "65727333001053367881220235421809751254540594752243" "52584907711670556013604839586446706324415722155397" "53697817977846174064955149290862569321978468622482" "83972241375657056057490261407972968652414535100474" "82166370484403199890008895243450658541227588666881" "16427171479924442928230863465674813919123162824586" "17866458359124566529476545682848912883142607690042" "24219022671055626321111109370544217506941658960408" "07198403850962455444362981230987879927244284909188" "84580156166097919133875499200524063689912560717606" "05886116467109405077541002256983155200055935729725" "71636269561882670428252483600823257530420752963450" ) def A ( _UpperCAmelCase : str = N ) -> int: '''simple docstring''' return max( # mypy cannot properly interpret reduce int(reduce(lambda _UpperCAmelCase , _UpperCAmelCase : str(int(_UpperCAmelCase ) * int(_UpperCAmelCase ) ) , n[i : i + 13] ) ) for i in range(len(_UpperCAmelCase ) - 12 ) ) if __name__ == "__main__": print(f"""{solution() = }""")
339
1
import functools import operator from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCAmelCase__ = logging.get_logger(__name__) UpperCAmelCase__ = { "asapp/sew-tiny-100k": "https://huggingface.co/asapp/sew-tiny-100k/resolve/main/config.json", # See all SEW models at https://huggingface.co/models?filter=sew } class __lowerCAmelCase ( A ): UpperCamelCase = '''sew''' def __init__( self : Optional[int] , A : Tuple=32 , A : Union[str, Any]=7_68 , A : Optional[Any]=12 , A : Dict=12 , A : List[Any]=30_72 , A : Optional[int]=2 , A : Optional[int]="gelu" , A : List[Any]=0.1 , A : List[Any]=0.1 , A : Optional[Any]=0.1 , A : Optional[Any]=0.0 , A : Tuple=0.1 , A : Union[str, Any]=0.1 , A : List[Any]=0.0_2 , A : str=1E-5 , A : Tuple="group" , A : Tuple="gelu" , A : int=(64, 1_28, 1_28, 1_28, 1_28, 2_56, 2_56, 2_56, 2_56, 5_12, 5_12, 5_12, 5_12) , A : Tuple=(5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1) , A : Optional[int]=(10, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1) , A : List[str]=False , A : Dict=1_28 , A : List[str]=16 , A : List[Any]=True , A : int=0.0_5 , A : Optional[Any]=10 , A : str=2 , A : Optional[Any]=0.0 , A : Union[str, Any]=10 , A : List[Any]=0 , A : Optional[int]="mean" , A : Tuple=False , A : str=False , A : Tuple=2_56 , A : Tuple=0 , A : Optional[int]=1 , A : Optional[int]=2 , **A : Any , ) -> Optional[Any]: """simple docstring""" super().__init__(**A , pad_token_id=A , bos_token_id=A , eos_token_id=A) _UpperCAmelCase = hidden_size _UpperCAmelCase = feat_extract_norm _UpperCAmelCase = feat_extract_activation _UpperCAmelCase = list(A) _UpperCAmelCase = list(A) _UpperCAmelCase = list(A) _UpperCAmelCase = conv_bias _UpperCAmelCase = num_conv_pos_embeddings _UpperCAmelCase = num_conv_pos_embedding_groups _UpperCAmelCase = len(self.conv_dim) _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = intermediate_size _UpperCAmelCase = squeeze_factor _UpperCAmelCase = hidden_act _UpperCAmelCase = num_attention_heads _UpperCAmelCase = hidden_dropout _UpperCAmelCase = attention_dropout _UpperCAmelCase = activation_dropout _UpperCAmelCase = feat_proj_dropout _UpperCAmelCase = final_dropout _UpperCAmelCase = layerdrop _UpperCAmelCase = layer_norm_eps _UpperCAmelCase = initializer_range _UpperCAmelCase = vocab_size if ( (len(self.conv_stride) != self.num_feat_extract_layers) or (len(self.conv_kernel) != self.num_feat_extract_layers) or (len(self.conv_dim) != self.num_feat_extract_layers) ): raise ValueError( 'Configuration for convolutional layers is incorrect.' 'It is required that `len(config.conv_dim)` == `len(config.conv_stride)` == `len(config.conv_kernel)`,' F"but is `len(config.conv_dim) = {len(self.conv_dim)}`, `len(config.conv_stride)" F"= {len(self.conv_stride)}`, `len(config.conv_kernel) = {len(self.conv_kernel)}`.") # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779 _UpperCAmelCase = apply_spec_augment _UpperCAmelCase = mask_time_prob _UpperCAmelCase = mask_time_length _UpperCAmelCase = mask_time_min_masks _UpperCAmelCase = mask_feature_prob _UpperCAmelCase = mask_feature_length _UpperCAmelCase = mask_feature_min_masks # ctc loss _UpperCAmelCase = ctc_loss_reduction _UpperCAmelCase = ctc_zero_infinity # sequence classification _UpperCAmelCase = use_weighted_layer_sum _UpperCAmelCase = classifier_proj_size @property def _lowerCamelCase ( self : int) -> Union[str, Any]: """simple docstring""" return functools.reduce(operator.mul , self.conv_stride , 1)
339
from __future__ import annotations from collections.abc import Callable UpperCAmelCase__ = list[list[float | int]] def A ( _UpperCAmelCase : Matrix , _UpperCAmelCase : Matrix ) -> Matrix: '''simple docstring''' _UpperCAmelCase = len(_UpperCAmelCase ) _UpperCAmelCase = [[0 for _ in range(size + 1 )] for _ in range(_UpperCAmelCase )] _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 for row in range(_UpperCAmelCase ): for col in range(_UpperCAmelCase ): _UpperCAmelCase = matrix[row][col] _UpperCAmelCase = vector[row][0] _UpperCAmelCase = 0 _UpperCAmelCase = 0 while row < size and col < size: # pivoting _UpperCAmelCase = max((abs(augmented[rowa][col] ), rowa) for rowa in range(_UpperCAmelCase , _UpperCAmelCase ) )[ 1 ] if augmented[pivot_row][col] == 0: col += 1 continue else: _UpperCAmelCase , _UpperCAmelCase = augmented[pivot_row], augmented[row] for rowa in range(row + 1 , _UpperCAmelCase ): _UpperCAmelCase = augmented[rowa][col] / augmented[row][col] _UpperCAmelCase = 0 for cola in range(col + 1 , size + 1 ): augmented[rowa][cola] -= augmented[row][cola] * ratio row += 1 col += 1 # back substitution for col in range(1 , _UpperCAmelCase ): for row in range(_UpperCAmelCase ): _UpperCAmelCase = augmented[row][col] / augmented[col][col] for cola in range(_UpperCAmelCase , size + 1 ): augmented[row][cola] -= augmented[col][cola] * ratio # round to get rid of numbers like 2.000000000000004 return [ [round(augmented[row][size] / augmented[row][row] , 10 )] for row in range(_UpperCAmelCase ) ] def A ( _UpperCAmelCase : list[int] ) -> Callable[[int], int]: '''simple docstring''' _UpperCAmelCase = len(_UpperCAmelCase ) _UpperCAmelCase = [[0 for _ in range(_UpperCAmelCase )] for _ in range(_UpperCAmelCase )] _UpperCAmelCase = [[0] for _ in range(_UpperCAmelCase )] _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 for x_val, y_val in enumerate(_UpperCAmelCase ): for col in range(_UpperCAmelCase ): _UpperCAmelCase = (x_val + 1) ** (size - col - 1) _UpperCAmelCase = y_val _UpperCAmelCase = solve(_UpperCAmelCase , _UpperCAmelCase ) def interpolated_func(_UpperCAmelCase : int ) -> int: return sum( round(coeffs[x_val][0] ) * (var ** (size - x_val - 1)) for x_val in range(_UpperCAmelCase ) ) return interpolated_func def A ( _UpperCAmelCase : int ) -> int: '''simple docstring''' return ( 1 - variable + variable**2 - variable**3 + variable**4 - variable**5 + variable**6 - variable**7 + variable**8 - variable**9 + variable**10 ) def A ( _UpperCAmelCase : Callable[[int], int] = question_function , _UpperCAmelCase : int = 10 ) -> int: '''simple docstring''' _UpperCAmelCase = [func(_UpperCAmelCase ) for x_val in range(1 , order + 1 )] _UpperCAmelCase = [ interpolate(data_points[:max_coeff] ) for max_coeff in range(1 , order + 1 ) ] _UpperCAmelCase = 0 _UpperCAmelCase = 42 _UpperCAmelCase = 42 for poly in polynomials: _UpperCAmelCase = 1 while func(_UpperCAmelCase ) == poly(_UpperCAmelCase ): x_val += 1 ret += poly(_UpperCAmelCase ) return ret if __name__ == "__main__": print(f"""{solution() = }""")
339
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_torch_available, ) UpperCAmelCase__ = { "configuration_gpt_bigcode": ["GPT_BIGCODE_PRETRAINED_CONFIG_ARCHIVE_MAP", "GPTBigCodeConfig"], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase__ = [ "GPT_BIGCODE_PRETRAINED_MODEL_ARCHIVE_LIST", "GPTBigCodeForSequenceClassification", "GPTBigCodeForTokenClassification", "GPTBigCodeForCausalLM", "GPTBigCodeModel", "GPTBigCodePreTrainedModel", ] if TYPE_CHECKING: from .configuration_gpt_bigcode import GPT_BIGCODE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTBigCodeConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_gpt_bigcode import ( GPT_BIGCODE_PRETRAINED_MODEL_ARCHIVE_LIST, GPTBigCodeForCausalLM, GPTBigCodeForSequenceClassification, GPTBigCodeForTokenClassification, GPTBigCodeModel, GPTBigCodePreTrainedModel, ) else: import sys UpperCAmelCase__ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
339
from __future__ import annotations def A ( _UpperCAmelCase : list[int] ) -> bool: '''simple docstring''' return len(set(_UpperCAmelCase ) ) == len(_UpperCAmelCase ) if __name__ == "__main__": import doctest doctest.testmod()
339
1
import warnings from transformers import AutoTokenizer from transformers.utils import is_torch_available from transformers.utils.generic import ExplicitEnum from ...processing_utils import ProcessorMixin if is_torch_available(): import torch class __lowerCAmelCase ( A ): UpperCamelCase = '''char''' UpperCamelCase = '''bpe''' UpperCamelCase = '''wp''' UpperCAmelCase__ = (DecodeType.CHARACTER, DecodeType.BPE, DecodeType.WORDPIECE) class __lowerCAmelCase ( A ): UpperCamelCase = ['''image_processor''', '''char_tokenizer'''] UpperCamelCase = '''ViTImageProcessor''' UpperCamelCase = '''MgpstrTokenizer''' def __init__( self : List[str] , A : Optional[Any]=None , A : Optional[int]=None , **A : Optional[int]) -> List[str]: """simple docstring""" _UpperCAmelCase = None if "feature_extractor" in kwargs: warnings.warn( 'The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`' ' instead.' , A , ) _UpperCAmelCase = kwargs.pop('feature_extractor') _UpperCAmelCase = image_processor if image_processor is not None else feature_extractor if image_processor is None: raise ValueError('You need to specify an `image_processor`.') if tokenizer is None: raise ValueError('You need to specify a `tokenizer`.') _UpperCAmelCase = tokenizer _UpperCAmelCase = AutoTokenizer.from_pretrained('gpt2') _UpperCAmelCase = AutoTokenizer.from_pretrained('bert-base-uncased') super().__init__(A , A) def __call__( self : List[str] , A : Union[str, Any]=None , A : Optional[int]=None , A : Union[str, Any]=None , **A : int) -> Optional[int]: """simple docstring""" if images is None and text is None: raise ValueError('You need to specify either an `images` or `text` input to process.') if images is not None: _UpperCAmelCase = self.image_processor(A , return_tensors=A , **A) if text is not None: _UpperCAmelCase = self.char_tokenizer(A , return_tensors=A , **A) if text is None: return inputs elif images is None: return encodings else: _UpperCAmelCase = encodings['input_ids'] return inputs def _lowerCamelCase ( self : int , A : List[Any]) -> Optional[int]: """simple docstring""" _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = sequences _UpperCAmelCase = char_preds.size(0) _UpperCAmelCase , _UpperCAmelCase = self._decode_helper(A , 'char') _UpperCAmelCase , _UpperCAmelCase = self._decode_helper(A , 'bpe') _UpperCAmelCase , _UpperCAmelCase = self._decode_helper(A , 'wp') _UpperCAmelCase = [] _UpperCAmelCase = [] for i in range(A): _UpperCAmelCase = [char_scores[i], bpe_scores[i], wp_scores[i]] _UpperCAmelCase = [char_strs[i], bpe_strs[i], wp_strs[i]] _UpperCAmelCase = scores.index(max(A)) final_strs.append(strs[max_score_index]) final_scores.append(scores[max_score_index]) _UpperCAmelCase = {} _UpperCAmelCase = final_strs _UpperCAmelCase = final_scores _UpperCAmelCase = char_strs _UpperCAmelCase = bpe_strs _UpperCAmelCase = wp_strs return out def _lowerCamelCase ( self : Tuple , A : List[Any] , A : List[str]) -> str: """simple docstring""" if format == DecodeType.CHARACTER: _UpperCAmelCase = self.char_decode _UpperCAmelCase = 1 _UpperCAmelCase = '[s]' elif format == DecodeType.BPE: _UpperCAmelCase = self.bpe_decode _UpperCAmelCase = 2 _UpperCAmelCase = '#' elif format == DecodeType.WORDPIECE: _UpperCAmelCase = self.wp_decode _UpperCAmelCase = 1_02 _UpperCAmelCase = '[SEP]' else: raise ValueError(F"Format {format} is not supported.") _UpperCAmelCase , _UpperCAmelCase = [], [] _UpperCAmelCase = pred_logits.size(0) _UpperCAmelCase = pred_logits.size(1) _UpperCAmelCase , _UpperCAmelCase = pred_logits.topk(1 , dim=-1 , largest=A , sorted=A) _UpperCAmelCase = preds_index.view(-1 , A)[:, 1:] _UpperCAmelCase = decoder(A) _UpperCAmelCase , _UpperCAmelCase = torch.nn.functional.softmax(A , dim=2).max(dim=2) _UpperCAmelCase = preds_max_prob[:, 1:] for index in range(A): _UpperCAmelCase = preds_str[index].find(A) _UpperCAmelCase = preds_str[index][:pred_eos] _UpperCAmelCase = preds_index[index].cpu().tolist() _UpperCAmelCase = pred_index.index(A) if eos_token in pred_index else -1 _UpperCAmelCase = preds_max_prob[index][: pred_eos_index + 1] _UpperCAmelCase = pred_max_prob.cumprod(dim=0)[-1] if pred_max_prob.nelement() != 0 else 0.0 dec_strs.append(A) conf_scores.append(A) return dec_strs, conf_scores def _lowerCamelCase ( self : List[str] , A : Dict) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = [seq.replace(' ' , '') for seq in self.char_tokenizer.batch_decode(A)] return decode_strs def _lowerCamelCase ( self : Optional[int] , A : Optional[int]) -> Union[str, Any]: """simple docstring""" return self.bpe_tokenizer.batch_decode(A) def _lowerCamelCase ( self : List[Any] , A : List[Any]) -> str: """simple docstring""" _UpperCAmelCase = [seq.replace(' ' , '') for seq in self.wp_tokenizer.batch_decode(A)] return decode_strs
339
import os UpperCAmelCase__ = {"I": 1, "V": 5, "X": 10, "L": 50, "C": 100, "D": 500, "M": 1000} def A ( _UpperCAmelCase : str ) -> int: '''simple docstring''' _UpperCAmelCase = 0 _UpperCAmelCase = 0 while index < len(_UpperCAmelCase ) - 1: _UpperCAmelCase = SYMBOLS[numerals[index]] _UpperCAmelCase = SYMBOLS[numerals[index + 1]] if current_value < next_value: total_value -= current_value else: total_value += current_value index += 1 total_value += SYMBOLS[numerals[index]] return total_value def A ( _UpperCAmelCase : int ) -> str: '''simple docstring''' _UpperCAmelCase = '' _UpperCAmelCase = num // 1_000 numerals += m_count * "M" num %= 1_000 _UpperCAmelCase = num // 100 if c_count == 9: numerals += "CM" c_count -= 9 elif c_count == 4: numerals += "CD" c_count -= 4 if c_count >= 5: numerals += "D" c_count -= 5 numerals += c_count * "C" num %= 100 _UpperCAmelCase = num // 10 if x_count == 9: numerals += "XC" x_count -= 9 elif x_count == 4: numerals += "XL" x_count -= 4 if x_count >= 5: numerals += "L" x_count -= 5 numerals += x_count * "X" num %= 10 if num == 9: numerals += "IX" num -= 9 elif num == 4: numerals += "IV" num -= 4 if num >= 5: numerals += "V" num -= 5 numerals += num * "I" return numerals def A ( _UpperCAmelCase : str = "/p089_roman.txt" ) -> int: '''simple docstring''' _UpperCAmelCase = 0 with open(os.path.dirname(_UpperCAmelCase ) + roman_numerals_filename ) as filea: _UpperCAmelCase = filea.readlines() for line in lines: _UpperCAmelCase = line.strip() _UpperCAmelCase = parse_roman_numerals(_UpperCAmelCase ) _UpperCAmelCase = generate_roman_numerals(_UpperCAmelCase ) savings += len(_UpperCAmelCase ) - len(_UpperCAmelCase ) return savings if __name__ == "__main__": print(f"""{solution() = }""")
339
1
from __future__ import annotations UpperCAmelCase__ = 8.988E9 # units = N * m^s * C^-2 def A ( _UpperCAmelCase : float , _UpperCAmelCase : float , _UpperCAmelCase : float , _UpperCAmelCase : float ) -> dict[str, float]: '''simple docstring''' _UpperCAmelCase = abs(chargea * chargea ) if (force, chargea, chargea, distance).count(0 ) != 1: raise ValueError('One and only one argument must be 0' ) if distance < 0: raise ValueError('Distance cannot be negative' ) if force == 0: _UpperCAmelCase = COULOMBS_CONSTANT * charge_product / (distance**2) return {"force": force} elif chargea == 0: _UpperCAmelCase = abs(_UpperCAmelCase ) * (distance**2) / (COULOMBS_CONSTANT * chargea) return {"charge1": chargea} elif chargea == 0: _UpperCAmelCase = abs(_UpperCAmelCase ) * (distance**2) / (COULOMBS_CONSTANT * chargea) return {"charge2": chargea} elif distance == 0: _UpperCAmelCase = (COULOMBS_CONSTANT * charge_product / abs(_UpperCAmelCase )) ** 0.5 return {"distance": distance} raise ValueError('Exactly one argument must be 0' ) if __name__ == "__main__": import doctest doctest.testmod()
339
import requests from bsa import BeautifulSoup def A ( _UpperCAmelCase : str , _UpperCAmelCase : dict ) -> str: '''simple docstring''' _UpperCAmelCase = BeautifulSoup(requests.get(_UpperCAmelCase , params=_UpperCAmelCase ).content , 'html.parser' ) _UpperCAmelCase = soup.find('div' , attrs={'class': 'gs_ri'} ) _UpperCAmelCase = div.find('div' , attrs={'class': 'gs_fl'} ).find_all('a' ) return anchors[2].get_text() if __name__ == "__main__": UpperCAmelCase__ = { "title": ( "Precisely geometry controlled microsupercapacitors for ultrahigh areal " "capacitance, volumetric capacitance, and energy density" ), "journal": "Chem. Mater.", "volume": 30, "pages": "3979-3990", "year": 2018, "hl": "en", } print(get_citation("https://scholar.google.com/scholar_lookup", params=params))
339
1
# XXX: we want transformers master here - in the absense of conftest manipulating sys.path: # hack it in for now: import sys from pathlib import Path UpperCAmelCase__ = Path(__file__).resolve().parents[3] / "src" sys.path.insert(1, str(git_repo_path)) import dataclasses # noqa import io # noqa import itertools # noqa import json # noqa import os # noqa import unittest # noqa from copy import deepcopy # noqa from parameterized import parameterized # noqa from transformers import TrainingArguments, is_torch_available # noqa from transformers.deepspeed import is_deepspeed_available # noqa from transformers.file_utils import WEIGHTS_NAME # noqa from transformers.testing_utils import ( # noqa CaptureLogger, ExtendSysPath, TestCasePlus, execute_subprocess_async, get_gpu_count, mockenv_context, require_deepspeed, require_torch_gpu, require_torch_multi_gpu, slow, ) from transformers.trainer_utils import set_seed # noqa set_seed(42) UpperCAmelCase__ = {"base": "patrickvonplaten/wav2vec2_tiny_random", "robust": "patrickvonplaten/wav2vec2_tiny_random_robust"} UpperCAmelCase__ = "zero2" UpperCAmelCase__ = "zero3" UpperCAmelCase__ = [ZEROa, ZEROa] def A ( _UpperCAmelCase : List[str] , _UpperCAmelCase : Tuple , _UpperCAmelCase : List[Any] ) -> Dict: '''simple docstring''' # customize the test name generator function as we want both params to appear in the sub-test # name, as by default it shows only the first param _UpperCAmelCase = parameterized.to_safe_name('_'.join(str(_UpperCAmelCase ) for x in param.args ) ) return F"{func.__name__}_{param_based_name}" # Cartesian-product of zero stages with models to test UpperCAmelCase__ = list(itertools.product(stages, models.keys())) @slow @require_deepspeed @require_torch_gpu class __lowerCAmelCase ( A ): @parameterized.expand(A , name_func=A) def _lowerCamelCase ( self : int , A : Union[str, Any] , A : List[str]) -> List[Any]: """simple docstring""" self.run_and_check( stage=A , model=A , distributed=A , fpaa=A , ) @require_torch_multi_gpu @parameterized.expand(A , name_func=A) def _lowerCamelCase ( self : int , A : Tuple , A : Tuple) -> Tuple: """simple docstring""" self.run_and_check( stage=A , model=A , distributed=A , fpaa=A , ) @parameterized.expand(A , name_func=A) def _lowerCamelCase ( self : Optional[Any] , A : List[str] , A : Optional[Any]) -> str: """simple docstring""" self.run_and_check( stage=A , model=A , distributed=A , fpaa=A , ) @require_torch_multi_gpu @parameterized.expand(A , name_func=A) def _lowerCamelCase ( self : Tuple , A : Optional[Any] , A : Tuple) -> Union[str, Any]: """simple docstring""" self.run_and_check( stage=A , model=A , distributed=A , fpaa=A , ) def _lowerCamelCase ( self : Optional[int] , A : Optional[int]) -> Tuple: """simple docstring""" pass def _lowerCamelCase ( self : List[Any] , A : str , A : str , A : int = 10 , A : bool = True , A : bool = True , A : bool = True , ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = models[model] _UpperCAmelCase = self.run_trainer( stage=A , model_name=A , eval_steps=A , num_train_epochs=1 , distributed=A , fpaa=A , ) self.do_checks(A) return output_dir def _lowerCamelCase ( self : List[str] , A : str , A : str , A : int = 10 , A : int = 1 , A : bool = True , A : bool = True , ) -> Any: """simple docstring""" _UpperCAmelCase = self.get_auto_remove_tmp_dir('./xxx' , after=A) _UpperCAmelCase = F"\n --model_name_or_path {model_name}\n --dataset_name hf-internal-testing/librispeech_asr_dummy\n --dataset_config_name clean\n --train_split_name validation\n --validation_split_name validation\n --output_dir {output_dir}\n --num_train_epochs {str(A)}\n --per_device_train_batch_size 2\n --per_device_eval_batch_size 2\n --evaluation_strategy steps\n --learning_rate 5e-4\n --warmup_steps 8\n --orthography timit\n --preprocessing_num_workers 1\n --group_by_length\n --freeze_feature_extractor\n --report_to none\n --save_steps 0\n --eval_steps {eval_steps}\n --report_to none\n ".split() if fpaa: args.extend(['--fp16']) # currently ds_config_wav2vec2_zero.json requires "zero_optimization.find_unused_parameters": true, # hence the separate config files _UpperCAmelCase = F"--deepspeed {self.test_file_dir_str}/ds_config_wav2vec2_{stage}.json".split() _UpperCAmelCase = [F"{self.examples_dir_str}/research_projects/wav2vec2/run_asr.py"] _UpperCAmelCase = self.get_launcher(A) _UpperCAmelCase = launcher + script + args + ds_args # keep for quick debug # print(" ".join([f"\nPYTHONPATH={self.src_dir_str}"] +cmd)); die execute_subprocess_async(A , env=self.get_env()) return output_dir def _lowerCamelCase ( self : Tuple , A : int=False) -> str: """simple docstring""" _UpperCAmelCase = min(2 , get_gpu_count()) if distributed else 1 return F"deepspeed --num_nodes 1 --num_gpus {num_gpus}".split()
339
import unittest import numpy as np from transformers import RoFormerConfig, 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.roformer.modeling_flax_roformer import ( FlaxRoFormerForMaskedLM, FlaxRoFormerForMultipleChoice, FlaxRoFormerForQuestionAnswering, FlaxRoFormerForSequenceClassification, FlaxRoFormerForTokenClassification, FlaxRoFormerModel, ) class __lowerCAmelCase ( unittest.TestCase ): def __init__( self : Optional[Any] , A : Dict , A : Union[str, Any]=13 , A : Dict=7 , A : Dict=True , A : Tuple=True , A : Union[str, Any]=True , A : int=True , A : Optional[int]=99 , A : List[str]=32 , A : List[Any]=5 , A : int=4 , A : Any=37 , A : Optional[int]="gelu" , A : Optional[Any]=0.1 , A : Any=0.1 , A : Union[str, Any]=5_12 , A : int=16 , A : List[str]=2 , A : Union[str, Any]=0.0_2 , A : Union[str, Any]=4 , ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = seq_length _UpperCAmelCase = is_training _UpperCAmelCase = use_attention_mask _UpperCAmelCase = use_token_type_ids _UpperCAmelCase = use_labels _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = type_vocab_size _UpperCAmelCase = type_sequence_label_size _UpperCAmelCase = initializer_range _UpperCAmelCase = num_choices def _lowerCamelCase ( self : Optional[Any]) -> List[Any]: """simple docstring""" _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size) _UpperCAmelCase = None if self.use_attention_mask: _UpperCAmelCase = random_attention_mask([self.batch_size, self.seq_length]) _UpperCAmelCase = None if self.use_token_type_ids: _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size) _UpperCAmelCase = RoFormerConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , is_decoder=A , initializer_range=self.initializer_range , ) return config, input_ids, token_type_ids, attention_mask def _lowerCamelCase ( self : List[Any]) -> List[str]: """simple docstring""" _UpperCAmelCase = self.prepare_config_and_inputs() _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = config_and_inputs _UpperCAmelCase = {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': attention_mask} return config, inputs_dict @require_flax class __lowerCAmelCase ( A , unittest.TestCase ): UpperCamelCase = True UpperCamelCase = ( ( FlaxRoFormerModel, FlaxRoFormerForMaskedLM, FlaxRoFormerForSequenceClassification, FlaxRoFormerForTokenClassification, FlaxRoFormerForMultipleChoice, FlaxRoFormerForQuestionAnswering, ) if is_flax_available() else () ) def _lowerCamelCase ( self : Optional[int]) -> Any: """simple docstring""" _UpperCAmelCase = FlaxRoFormerModelTester(self) @slow def _lowerCamelCase ( self : List[Any]) -> Dict: """simple docstring""" for model_class_name in self.all_model_classes: _UpperCAmelCase = model_class_name.from_pretrained('junnyu/roformer_chinese_small' , from_pt=A) _UpperCAmelCase = model(np.ones((1, 1))) self.assertIsNotNone(A) @require_flax class __lowerCAmelCase ( unittest.TestCase ): @slow def _lowerCamelCase ( self : List[Any]) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = FlaxRoFormerForMaskedLM.from_pretrained('junnyu/roformer_chinese_base') _UpperCAmelCase = jnp.array([[0, 1, 2, 3, 4, 5]]) _UpperCAmelCase = model(A)[0] _UpperCAmelCase = 5_00_00 _UpperCAmelCase = (1, 6, vocab_size) self.assertEqual(output.shape , A) _UpperCAmelCase = jnp.array( [[[-0.1_2_0_5, -1.0_2_6_5, 0.2_9_2_2], [-1.5_1_3_4, 0.1_9_7_4, 0.1_5_1_9], [-5.0_1_3_5, -3.9_0_0_3, -0.8_4_0_4]]]) self.assertTrue(jnp.allclose(output[:, :3, :3] , A , atol=1E-4))
339
1
from .dependency_versions_table import deps from .utils.versions import require_version, require_version_core # define which module versions we always want to check at run time # (usually the ones defined in `install_requires` in setup.py) # # order specific notes: # - tqdm must be checked before tokenizers UpperCAmelCase__ = [ "python", "tqdm", "regex", "requests", "packaging", "filelock", "numpy", "tokenizers", "huggingface-hub", "safetensors", "accelerate", "pyyaml", ] for pkg in pkgs_to_check_at_runtime: if pkg in deps: if pkg == "tokenizers": # must be loaded here, or else tqdm check may fail from .utils import is_tokenizers_available if not is_tokenizers_available(): continue # not required, check version only if installed elif pkg == "accelerate": # must be loaded here, or else tqdm check may fail from .utils import is_accelerate_available # Maybe switch to is_torch_available in the future here so that Accelerate is hard dep of # Transformers with PyTorch if not is_accelerate_available(): continue # not required, check version only if installed require_version_core(deps[pkg]) else: raise ValueError(f"""can't find {pkg} in {deps.keys()}, check dependency_versions_table.py""") def A ( _UpperCAmelCase : List[Any] , _UpperCAmelCase : Dict=None ) -> str: '''simple docstring''' require_version(deps[pkg] , _UpperCAmelCase )
339
UpperCAmelCase__ = {} def A ( _UpperCAmelCase : int , _UpperCAmelCase : int , _UpperCAmelCase : int ) -> int: '''simple docstring''' # if we are absent twice, or late 3 consecutive days, # no further prize strings are possible if late == 3 or absent == 2: return 0 # if we have no days left, and have not failed any other rules, # we have a prize string if days == 0: return 1 # No easy solution, so now we need to do the recursive calculation # First, check if the combination is already in the cache, and # if yes, return the stored value from there since we already # know the number of possible prize strings from this point on _UpperCAmelCase = (days, absent, late) if key in cache: return cache[key] # now we calculate the three possible ways that can unfold from # this point on, depending on our attendance today # 1) if we are late (but not absent), the "absent" counter stays as # it is, but the "late" counter increases by one _UpperCAmelCase = _calculate(days - 1 , _UpperCAmelCase , late + 1 ) # 2) if we are absent, the "absent" counter increases by 1, and the # "late" counter resets to 0 _UpperCAmelCase = _calculate(days - 1 , absent + 1 , 0 ) # 3) if we are on time, this resets the "late" counter and keeps the # absent counter _UpperCAmelCase = _calculate(days - 1 , _UpperCAmelCase , 0 ) _UpperCAmelCase = state_late + state_absent + state_ontime _UpperCAmelCase = prizestrings return prizestrings def A ( _UpperCAmelCase : int = 30 ) -> int: '''simple docstring''' return _calculate(_UpperCAmelCase , absent=0 , late=0 ) if __name__ == "__main__": print(solution())
339
1
UpperCAmelCase__ = [0, 2, 4, 6, 8] UpperCAmelCase__ = [1, 3, 5, 7, 9] def A ( _UpperCAmelCase : int , _UpperCAmelCase : int , _UpperCAmelCase : list[int] , _UpperCAmelCase : int ) -> int: '''simple docstring''' if remaining_length == 0: if digits[0] == 0 or digits[-1] == 0: return 0 for i in range(length // 2 - 1 , -1 , -1 ): remainder += digits[i] + digits[length - i - 1] if remainder % 2 == 0: return 0 remainder //= 10 return 1 if remaining_length == 1: if remainder % 2 == 0: return 0 _UpperCAmelCase = 0 for digit in range(10 ): _UpperCAmelCase = digit result += reversible_numbers( 0 , (remainder + 2 * digit) // 10 , _UpperCAmelCase , _UpperCAmelCase ) return result _UpperCAmelCase = 0 for digita in range(10 ): _UpperCAmelCase = digita if (remainder + digita) % 2 == 0: _UpperCAmelCase = ODD_DIGITS else: _UpperCAmelCase = EVEN_DIGITS for digita in other_parity_digits: _UpperCAmelCase = digita result += reversible_numbers( remaining_length - 2 , (remainder + digita + digita) // 10 , _UpperCAmelCase , _UpperCAmelCase , ) return result def A ( _UpperCAmelCase : int = 9 ) -> int: '''simple docstring''' _UpperCAmelCase = 0 for length in range(1 , max_power + 1 ): result += reversible_numbers(_UpperCAmelCase , 0 , [0] * length , _UpperCAmelCase ) return result if __name__ == "__main__": print(f"""{solution() = }""")
339
import os import sys import unittest UpperCAmelCase__ = 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_dummies # noqa: E402 from check_dummies import create_dummy_files, create_dummy_object, find_backend, read_init # noqa: E402 # Align TRANSFORMERS_PATH in check_dummies with the current path UpperCAmelCase__ = os.path.join(git_repo_path, "src", "diffusers") class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Tuple) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = find_backend(' if not is_torch_available():') self.assertEqual(A , 'torch') # backend_with_underscore = find_backend(" if not is_tensorflow_text_available():") # self.assertEqual(backend_with_underscore, "tensorflow_text") _UpperCAmelCase = find_backend(' if not (is_torch_available() and is_transformers_available()):') self.assertEqual(A , 'torch_and_transformers') # double_backend_with_underscore = find_backend( # " if not (is_sentencepiece_available() and is_tensorflow_text_available()):" # ) # self.assertEqual(double_backend_with_underscore, "sentencepiece_and_tensorflow_text") _UpperCAmelCase = find_backend( ' if not (is_torch_available() and is_transformers_available() and is_onnx_available()):') self.assertEqual(A , 'torch_and_transformers_and_onnx') def _lowerCamelCase ( self : int) -> Dict: """simple docstring""" _UpperCAmelCase = read_init() # We don't assert on the exact list of keys to allow for smooth grow of backend-specific objects self.assertIn('torch' , A) self.assertIn('torch_and_transformers' , A) self.assertIn('flax_and_transformers' , A) self.assertIn('torch_and_transformers_and_onnx' , A) # Likewise, we can't assert on the exact content of a key self.assertIn('UNet2DModel' , objects['torch']) self.assertIn('FlaxUNet2DConditionModel' , objects['flax']) self.assertIn('StableDiffusionPipeline' , objects['torch_and_transformers']) self.assertIn('FlaxStableDiffusionPipeline' , objects['flax_and_transformers']) self.assertIn('LMSDiscreteScheduler' , objects['torch_and_scipy']) self.assertIn('OnnxStableDiffusionPipeline' , objects['torch_and_transformers_and_onnx']) def _lowerCamelCase ( self : Union[str, Any]) -> List[Any]: """simple docstring""" _UpperCAmelCase = create_dummy_object('CONSTANT' , '\'torch\'') self.assertEqual(A , '\nCONSTANT = None\n') _UpperCAmelCase = create_dummy_object('function' , '\'torch\'') self.assertEqual( A , '\ndef function(*args, **kwargs):\n requires_backends(function, \'torch\')\n') _UpperCAmelCase = '\nclass FakeClass(metaclass=DummyObject):\n _backends = \'torch\'\n\n def __init__(self, *args, **kwargs):\n requires_backends(self, \'torch\')\n\n @classmethod\n def from_config(cls, *args, **kwargs):\n requires_backends(cls, \'torch\')\n\n @classmethod\n def from_pretrained(cls, *args, **kwargs):\n requires_backends(cls, \'torch\')\n' _UpperCAmelCase = create_dummy_object('FakeClass' , '\'torch\'') self.assertEqual(A , A) def _lowerCamelCase ( self : Dict) -> int: """simple docstring""" _UpperCAmelCase = '# This file is autogenerated by the command `make fix-copies`, do not edit.\nfrom ..utils import DummyObject, requires_backends\n\n\nCONSTANT = None\n\n\ndef function(*args, **kwargs):\n requires_backends(function, ["torch"])\n\n\nclass FakeClass(metaclass=DummyObject):\n _backends = ["torch"]\n\n def __init__(self, *args, **kwargs):\n requires_backends(self, ["torch"])\n\n @classmethod\n def from_config(cls, *args, **kwargs):\n requires_backends(cls, ["torch"])\n\n @classmethod\n def from_pretrained(cls, *args, **kwargs):\n requires_backends(cls, ["torch"])\n' _UpperCAmelCase = create_dummy_files({'torch': ['CONSTANT', 'function', 'FakeClass']}) self.assertEqual(dummy_files['torch'] , A)
339
1
import json import os from functools import lru_cache from typing import List, Optional, Tuple import regex as re from ...tokenization_utils import AddedToken, PreTrainedTokenizer from ...utils import logging UpperCAmelCase__ = logging.get_logger(__name__) UpperCAmelCase__ = {"vocab_file": "vocab.json", "merges_file": "merges.txt"} UpperCAmelCase__ = { "vocab_file": { "allenai/longformer-base-4096": "https://huggingface.co/allenai/longformer-base-4096/resolve/main/vocab.json", "allenai/longformer-large-4096": ( "https://huggingface.co/allenai/longformer-large-4096/resolve/main/vocab.json" ), "allenai/longformer-large-4096-finetuned-triviaqa": ( "https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/vocab.json" ), "allenai/longformer-base-4096-extra.pos.embd.only": ( "https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/vocab.json" ), "allenai/longformer-large-4096-extra.pos.embd.only": ( "https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/vocab.json" ), }, "merges_file": { "allenai/longformer-base-4096": "https://huggingface.co/allenai/longformer-base-4096/resolve/main/merges.txt", "allenai/longformer-large-4096": ( "https://huggingface.co/allenai/longformer-large-4096/resolve/main/merges.txt" ), "allenai/longformer-large-4096-finetuned-triviaqa": ( "https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/merges.txt" ), "allenai/longformer-base-4096-extra.pos.embd.only": ( "https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/merges.txt" ), "allenai/longformer-large-4096-extra.pos.embd.only": ( "https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/merges.txt" ), }, } UpperCAmelCase__ = { "allenai/longformer-base-4096": 4096, "allenai/longformer-large-4096": 4096, "allenai/longformer-large-4096-finetuned-triviaqa": 4096, "allenai/longformer-base-4096-extra.pos.embd.only": 4096, "allenai/longformer-large-4096-extra.pos.embd.only": 4096, } @lru_cache() # Copied from transformers.models.roberta.tokenization_roberta.bytes_to_unicode def A ( ) -> List[Any]: '''simple docstring''' _UpperCAmelCase = ( list(range(ord('!' ) , ord('~' ) + 1 ) ) + list(range(ord('¡' ) , ord('¬' ) + 1 ) ) + list(range(ord('®' ) , ord('ÿ' ) + 1 ) ) ) _UpperCAmelCase = bs[:] _UpperCAmelCase = 0 for b in range(2**8 ): if b not in bs: bs.append(_UpperCAmelCase ) cs.append(2**8 + n ) n += 1 _UpperCAmelCase = [chr(_UpperCAmelCase ) for n in cs] return dict(zip(_UpperCAmelCase , _UpperCAmelCase ) ) def A ( _UpperCAmelCase : Any ) -> Dict: '''simple docstring''' _UpperCAmelCase = set() _UpperCAmelCase = word[0] for char in word[1:]: pairs.add((prev_char, char) ) _UpperCAmelCase = char return pairs class __lowerCAmelCase ( A ): UpperCamelCase = VOCAB_FILES_NAMES UpperCamelCase = PRETRAINED_VOCAB_FILES_MAP UpperCamelCase = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES UpperCamelCase = ['''input_ids''', '''attention_mask'''] def __init__( self : int , A : str , A : int , A : int="replace" , A : List[str]="<s>" , A : Any="</s>" , A : List[str]="</s>" , A : Optional[Any]="<s>" , A : Dict="<unk>" , A : int="<pad>" , A : Tuple="<mask>" , A : Any=False , **A : Dict , ) -> Dict: """simple docstring""" _UpperCAmelCase = AddedToken(A , lstrip=A , rstrip=A) if isinstance(A , A) else bos_token _UpperCAmelCase = AddedToken(A , lstrip=A , rstrip=A) if isinstance(A , A) else eos_token _UpperCAmelCase = AddedToken(A , lstrip=A , rstrip=A) if isinstance(A , A) else sep_token _UpperCAmelCase = AddedToken(A , lstrip=A , rstrip=A) if isinstance(A , A) else cls_token _UpperCAmelCase = AddedToken(A , lstrip=A , rstrip=A) if isinstance(A , A) else unk_token _UpperCAmelCase = AddedToken(A , lstrip=A , rstrip=A) if isinstance(A , A) else pad_token # Mask token behave like a normal word, i.e. include the space before it _UpperCAmelCase = AddedToken(A , lstrip=A , rstrip=A) if isinstance(A , A) else mask_token super().__init__( errors=A , bos_token=A , eos_token=A , unk_token=A , sep_token=A , cls_token=A , pad_token=A , mask_token=A , add_prefix_space=A , **A , ) with open(A , encoding='utf-8') as vocab_handle: _UpperCAmelCase = json.load(A) _UpperCAmelCase = {v: k for k, v in self.encoder.items()} _UpperCAmelCase = errors # how to handle errors in decoding _UpperCAmelCase = bytes_to_unicode() _UpperCAmelCase = {v: k for k, v in self.byte_encoder.items()} with open(A , encoding='utf-8') as merges_handle: _UpperCAmelCase = merges_handle.read().split('\n')[1:-1] _UpperCAmelCase = [tuple(merge.split()) for merge in bpe_merges] _UpperCAmelCase = dict(zip(A , range(len(A)))) _UpperCAmelCase = {} _UpperCAmelCase = add_prefix_space # Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions _UpperCAmelCase = re.compile(R'\'s|\'t|\'re|\'ve|\'m|\'ll|\'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+') @property def _lowerCamelCase ( self : Optional[Any]) -> Union[str, Any]: """simple docstring""" return len(self.encoder) def _lowerCamelCase ( self : List[Any]) -> Any: """simple docstring""" return dict(self.encoder , **self.added_tokens_encoder) def _lowerCamelCase ( self : int , A : Tuple) -> Union[str, Any]: """simple docstring""" if token in self.cache: return self.cache[token] _UpperCAmelCase = tuple(A) _UpperCAmelCase = get_pairs(A) if not pairs: return token while True: _UpperCAmelCase = min(A , key=lambda A: self.bpe_ranks.get(A , float('inf'))) if bigram not in self.bpe_ranks: break _UpperCAmelCase , _UpperCAmelCase = bigram _UpperCAmelCase = [] _UpperCAmelCase = 0 while i < len(A): try: _UpperCAmelCase = word.index(A , A) except ValueError: new_word.extend(word[i:]) break else: new_word.extend(word[i:j]) _UpperCAmelCase = j if word[i] == first and i < len(A) - 1 and word[i + 1] == second: new_word.append(first + second) i += 2 else: new_word.append(word[i]) i += 1 _UpperCAmelCase = tuple(A) _UpperCAmelCase = new_word if len(A) == 1: break else: _UpperCAmelCase = get_pairs(A) _UpperCAmelCase = ' '.join(A) _UpperCAmelCase = word return word def _lowerCamelCase ( self : Union[str, Any] , A : str) -> str: """simple docstring""" _UpperCAmelCase = [] for token in re.findall(self.pat , A): _UpperCAmelCase = ''.join( self.byte_encoder[b] for b in token.encode('utf-8')) # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case) bpe_tokens.extend(bpe_token for bpe_token in self.bpe(A).split(' ')) return bpe_tokens def _lowerCamelCase ( self : Union[str, Any] , A : Any) -> int: """simple docstring""" return self.encoder.get(A , self.encoder.get(self.unk_token)) def _lowerCamelCase ( self : List[Any] , A : Dict) -> List[str]: """simple docstring""" return self.decoder.get(A) def _lowerCamelCase ( self : Optional[int] , A : int) -> Tuple: """simple docstring""" _UpperCAmelCase = ''.join(A) _UpperCAmelCase = bytearray([self.byte_decoder[c] for c in text]).decode('utf-8' , errors=self.errors) return text def _lowerCamelCase ( self : Optional[Any] , A : str , A : Optional[str] = None) -> Tuple[str]: """simple docstring""" if not os.path.isdir(A): logger.error(F"Vocabulary path ({save_directory}) should be a directory") return _UpperCAmelCase = os.path.join( A , (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']) _UpperCAmelCase = os.path.join( A , (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['merges_file']) with open(A , 'w' , encoding='utf-8') as f: f.write(json.dumps(self.encoder , indent=2 , sort_keys=A , ensure_ascii=A) + '\n') _UpperCAmelCase = 0 with open(A , 'w' , encoding='utf-8') as writer: writer.write('#version: 0.2\n') for bpe_tokens, token_index in sorted(self.bpe_ranks.items() , key=lambda A: kv[1]): if index != token_index: logger.warning( F"Saving vocabulary to {merge_file}: BPE merge indices are not consecutive." ' Please check that the tokenizer is not corrupted!') _UpperCAmelCase = token_index writer.write(' '.join(A) + '\n') index += 1 return vocab_file, merge_file def _lowerCamelCase ( self : Dict , A : List[int] , A : Optional[List[int]] = None) -> List[int]: """simple docstring""" if token_ids_a is None: return [self.cls_token_id] + token_ids_a + [self.sep_token_id] _UpperCAmelCase = [self.cls_token_id] _UpperCAmelCase = [self.sep_token_id] return cls + token_ids_a + sep + sep + token_ids_a + sep def _lowerCamelCase ( self : Optional[Any] , A : List[int] , A : Optional[List[int]] = None , A : bool = False) -> List[int]: """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) if token_ids_a is None: return [1] + ([0] * len(A)) + [1] return [1] + ([0] * len(A)) + [1, 1] + ([0] * len(A)) + [1] def _lowerCamelCase ( self : List[Any] , A : List[int] , A : Optional[List[int]] = None) -> List[int]: """simple docstring""" _UpperCAmelCase = [self.sep_token_id] _UpperCAmelCase = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep) * [0] return len(cls + token_ids_a + sep + sep + token_ids_a + sep) * [0] def _lowerCamelCase ( self : List[str] , A : int , A : str=False , **A : Dict) -> Dict: """simple docstring""" _UpperCAmelCase = kwargs.pop('add_prefix_space' , self.add_prefix_space) if (is_split_into_words or add_prefix_space) and (len(A) > 0 and not text[0].isspace()): _UpperCAmelCase = ' ' + text return (text, kwargs)
339
import logging import os import random import sys from dataclasses import dataclass, field from typing import Optional import datasets import numpy as np import pandas as pd from datasets import load_dataset import transformers from transformers import ( AutoConfig, BartForSequenceClassification, DataCollatorWithPadding, EvalPrediction, HfArgumentParser, TapexTokenizer, Trainer, TrainingArguments, default_data_collator, set_seed, ) from transformers.trainer_utils import get_last_checkpoint from transformers.utils import check_min_version from transformers.utils.versions import require_version # Will error if the minimal version of Transformers is not installed. Remove at your own risks. check_min_version("4.17.0.dev0") require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/text-classification/requirements.txt") UpperCAmelCase__ = logging.getLogger(__name__) @dataclass class __lowerCAmelCase : UpperCamelCase = field( default='''tab_fact''' , metadata={'''help''': '''The name of the dataset to use (via the datasets library).'''} ) UpperCamelCase = field( default='''tab_fact''' , metadata={'''help''': '''The configuration name of the dataset to use (via the datasets library).'''} , ) UpperCamelCase = field( default=1_0_2_4 , metadata={ '''help''': ( '''The maximum total input sequence length after tokenization. Sequences longer ''' '''than this will be truncated, sequences shorter will be padded.''' ) } , ) UpperCamelCase = field( default=A , metadata={'''help''': '''Overwrite the cached preprocessed datasets or not.'''} ) UpperCamelCase = field( default=A , 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.''' ) } , ) UpperCamelCase = field( default=A , metadata={ '''help''': ( '''For debugging purposes or quicker training, truncate the number of training examples to this ''' '''value if set.''' ) } , ) UpperCamelCase = field( default=A , metadata={ '''help''': ( '''For debugging purposes or quicker training, truncate the number of evaluation examples to this ''' '''value if set.''' ) } , ) UpperCamelCase = field( default=A , metadata={ '''help''': ( '''For debugging purposes or quicker training, truncate the number of prediction examples to this ''' '''value if set.''' ) } , ) UpperCamelCase = field( default=A , metadata={'''help''': '''A csv or a json file containing the training data.'''} ) UpperCamelCase = field( default=A , metadata={'''help''': '''A csv or a json file containing the validation data.'''} ) UpperCamelCase = field(default=A , metadata={'''help''': '''A csv or a json file containing the test data.'''} ) def _lowerCamelCase ( self : str) -> List[Any]: """simple docstring""" if self.dataset_name is not None: pass elif self.train_file is None or self.validation_file is None: raise ValueError('Need either a GLUE task, a training/validation file or a dataset name.') else: _UpperCAmelCase = self.train_file.split('.')[-1] assert train_extension in ["csv", "json"], "`train_file` should be a csv or a json file." _UpperCAmelCase = self.validation_file.split('.')[-1] assert ( validation_extension == train_extension ), "`validation_file` should have the same extension (csv or json) as `train_file`." @dataclass class __lowerCAmelCase : UpperCamelCase = field( default=A , metadata={'''help''': '''Path to pretrained model or model identifier from huggingface.co/models'''} ) UpperCamelCase = field( default=A , metadata={'''help''': '''Pretrained config name or path if not the same as model_name'''} ) UpperCamelCase = field( default=A , metadata={'''help''': '''Pretrained tokenizer name or path if not the same as model_name'''} ) UpperCamelCase = field( default=A , metadata={'''help''': '''Where do you want to store the pretrained models downloaded from huggingface.co'''} , ) UpperCamelCase = field( default=A , metadata={'''help''': '''Whether to use one of the fast tokenizer (backed by the tokenizers library) or not.'''} , ) UpperCamelCase = field( default='''main''' , metadata={'''help''': '''The specific model version to use (can be a branch name, tag name or commit id).'''} , ) UpperCamelCase = field( default=A , metadata={ '''help''': ( '''Will use the token generated when running `huggingface-cli login` (necessary to use this script ''' '''with private models).''' ) } , ) def A ( ) -> Optional[int]: '''simple docstring''' # See all possible arguments in src/transformers/training_args.py # or by passing the --help flag to this script. # We now keep distinct sets of args, for a cleaner separation of concerns. _UpperCAmelCase = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments) ) if len(sys.argv ) == 2 and sys.argv[1].endswith('.json' ): # If we pass only one argument to the script and it's the path to a json file, # let's parse it to get our arguments. _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1] ) ) else: _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = parser.parse_args_into_dataclasses() # Setup logging logging.basicConfig( format='%(asctime)s - %(levelname)s - %(name)s - %(message)s' , datefmt='%m/%d/%Y %H:%M:%S' , handlers=[logging.StreamHandler(sys.stdout )] , ) _UpperCAmelCase = training_args.get_process_log_level() logger.setLevel(_UpperCAmelCase ) datasets.utils.logging.set_verbosity(_UpperCAmelCase ) transformers.utils.logging.set_verbosity(_UpperCAmelCase ) transformers.utils.logging.enable_default_handler() transformers.utils.logging.enable_explicit_format() # Log on each process the small summary: logger.warning( F"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}" + F"distributed training: {bool(training_args.local_rank != -1 )}, 16-bits training: {training_args.fpaa}" ) logger.info(F"Training/evaluation parameters {training_args}" ) # Detecting last checkpoint. _UpperCAmelCase = None if os.path.isdir(training_args.output_dir ) and training_args.do_train and not training_args.overwrite_output_dir: _UpperCAmelCase = get_last_checkpoint(training_args.output_dir ) if last_checkpoint is None and len(os.listdir(training_args.output_dir ) ) > 0: raise ValueError( F"Output directory ({training_args.output_dir}) already exists and is not empty. " 'Use --overwrite_output_dir to overcome.' ) elif last_checkpoint is not None and training_args.resume_from_checkpoint is None: logger.info( F"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change " 'the `--output_dir` or add `--overwrite_output_dir` to train from scratch.' ) # Set seed before initializing model. set_seed(training_args.seed ) # Get the datasets: you can either provide your own CSV/JSON training and evaluation files (see below) # or specify a GLUE benchmark task (the dataset will be downloaded automatically from the datasets Hub). # # For JSON files, this script will use the `question` column for the input question and `table` column for the corresponding table. # # If the CSVs/JSONs contain only one non-label column, the script does single sentence classification on this # single column. You can easily tweak this behavior (see below) # # In distributed training, the load_dataset function guarantee that only one local process can concurrently # download the dataset. if data_args.dataset_name is not None: # Downloading and loading a dataset from the hub. _UpperCAmelCase = load_dataset( data_args.dataset_name , data_args.dataset_config_name , cache_dir=model_args.cache_dir ) else: # Loading a dataset from your local files. # CSV/JSON training and evaluation files are needed. _UpperCAmelCase = {'train': data_args.train_file, 'validation': data_args.validation_file} # Get the test dataset: you can provide your own CSV/JSON test file (see below) # when you use `do_predict` without specifying a GLUE benchmark task. if training_args.do_predict: if data_args.test_file is not None: _UpperCAmelCase = data_args.train_file.split('.' )[-1] _UpperCAmelCase = data_args.test_file.split('.' )[-1] assert ( test_extension == train_extension ), "`test_file` should have the same extension (csv or json) as `train_file`." _UpperCAmelCase = data_args.test_file else: raise ValueError('Need either a GLUE task or a test file for `do_predict`.' ) for key in data_files.keys(): logger.info(F"load a local file for {key}: {data_files[key]}" ) if data_args.train_file.endswith('.csv' ): # Loading a dataset from local csv files _UpperCAmelCase = load_dataset('csv' , data_files=_UpperCAmelCase , cache_dir=model_args.cache_dir ) else: # Loading a dataset from local json files _UpperCAmelCase = load_dataset('json' , data_files=_UpperCAmelCase , cache_dir=model_args.cache_dir ) # See more about loading any type of standard or custom dataset at # https://huggingface.co/docs/datasets/loading_datasets.html. # Labels _UpperCAmelCase = raw_datasets['train'].features['label'].names _UpperCAmelCase = len(_UpperCAmelCase ) # Load pretrained model and tokenizer # # In distributed training, the .from_pretrained methods guarantee that only one local process can concurrently # download model & vocab. _UpperCAmelCase = AutoConfig.from_pretrained( model_args.config_name if model_args.config_name else model_args.model_name_or_path , num_labels=_UpperCAmelCase , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , ) # load tapex tokenizer _UpperCAmelCase = TapexTokenizer.from_pretrained( model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path , cache_dir=model_args.cache_dir , use_fast=model_args.use_fast_tokenizer , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , add_prefix_space=_UpperCAmelCase , ) _UpperCAmelCase = BartForSequenceClassification.from_pretrained( model_args.model_name_or_path , from_tf=bool('.ckpt' in model_args.model_name_or_path ) , config=_UpperCAmelCase , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , ) # Padding strategy if data_args.pad_to_max_length: _UpperCAmelCase = 'max_length' else: # We will pad later, dynamically at batch creation, to the max sequence length in each batch _UpperCAmelCase = False # Some models have set the order of the labels to use, so let's make sure we do use it. _UpperCAmelCase = {'Refused': 0, 'Entailed': 1} _UpperCAmelCase = {0: 'Refused', 1: 'Entailed'} if data_args.max_seq_length > tokenizer.model_max_length: logger.warning( F"The max_seq_length passed ({data_args.max_seq_length}) is larger than the maximum length for the" F"model ({tokenizer.model_max_length}). Using max_seq_length={tokenizer.model_max_length}." ) _UpperCAmelCase = min(data_args.max_seq_length , tokenizer.model_max_length ) def preprocess_tabfact_function(_UpperCAmelCase : Union[str, Any] ): # Tokenize the texts def _convert_table_text_to_pandas(_UpperCAmelCase : Dict ): _UpperCAmelCase = [_table_row.split('#' ) for _table_row in _table_text.strip('\n' ).split('\n' )] _UpperCAmelCase = pd.DataFrame.from_records(_table_content[1:] , columns=_table_content[0] ) return _table_pd _UpperCAmelCase = examples['statement'] _UpperCAmelCase = list(map(_convert_table_text_to_pandas , examples['table_text'] ) ) _UpperCAmelCase = tokenizer(_UpperCAmelCase , _UpperCAmelCase , padding=_UpperCAmelCase , max_length=_UpperCAmelCase , truncation=_UpperCAmelCase ) _UpperCAmelCase = examples['label'] return result with training_args.main_process_first(desc='dataset map pre-processing' ): _UpperCAmelCase = raw_datasets.map( _UpperCAmelCase , batched=_UpperCAmelCase , load_from_cache_file=not data_args.overwrite_cache , desc='Running tokenizer on dataset' , ) if training_args.do_train: if "train" not in raw_datasets: raise ValueError('--do_train requires a train dataset' ) _UpperCAmelCase = raw_datasets['train'] if data_args.max_train_samples is not None: _UpperCAmelCase = train_dataset.select(range(data_args.max_train_samples ) ) if training_args.do_eval: if "validation" not in raw_datasets and "validation_matched" not in raw_datasets: raise ValueError('--do_eval requires a validation dataset' ) _UpperCAmelCase = raw_datasets['validation'] if data_args.max_eval_samples is not None: _UpperCAmelCase = eval_dataset.select(range(data_args.max_eval_samples ) ) if training_args.do_predict or data_args.test_file is not None: if "test" not in raw_datasets and "test_matched" not in raw_datasets: raise ValueError('--do_predict requires a test dataset' ) _UpperCAmelCase = raw_datasets['test'] if data_args.max_predict_samples is not None: _UpperCAmelCase = predict_dataset.select(range(data_args.max_predict_samples ) ) # Log a few random samples from the training set: if training_args.do_train: for index in random.sample(range(len(_UpperCAmelCase ) ) , 3 ): logger.info(F"Sample {index} of the training set: {train_dataset[index]}." ) # You can define your custom compute_metrics function. It takes an `EvalPrediction` object (a namedtuple with a # predictions and label_ids field) and has to return a dictionary string to float. def compute_metrics(_UpperCAmelCase : EvalPrediction ): _UpperCAmelCase = p.predictions[0] if isinstance(p.predictions , _UpperCAmelCase ) else p.predictions _UpperCAmelCase = np.argmax(_UpperCAmelCase , axis=1 ) return {"accuracy": (preds == p.label_ids).astype(np.floataa ).mean().item()} # Data collator will default to DataCollatorWithPadding, so we change it if we already did the padding. if data_args.pad_to_max_length: _UpperCAmelCase = default_data_collator elif training_args.fpaa: _UpperCAmelCase = DataCollatorWithPadding(_UpperCAmelCase , pad_to_multiple_of=8 ) else: _UpperCAmelCase = None # Initialize our Trainer _UpperCAmelCase = Trainer( model=_UpperCAmelCase , args=_UpperCAmelCase , train_dataset=train_dataset if training_args.do_train else None , eval_dataset=eval_dataset if training_args.do_eval else None , compute_metrics=_UpperCAmelCase , tokenizer=_UpperCAmelCase , data_collator=_UpperCAmelCase , ) # Training if training_args.do_train: _UpperCAmelCase = None if training_args.resume_from_checkpoint is not None: _UpperCAmelCase = training_args.resume_from_checkpoint elif last_checkpoint is not None: _UpperCAmelCase = last_checkpoint _UpperCAmelCase = trainer.train(resume_from_checkpoint=_UpperCAmelCase ) _UpperCAmelCase = train_result.metrics _UpperCAmelCase = ( data_args.max_train_samples if data_args.max_train_samples is not None else len(_UpperCAmelCase ) ) _UpperCAmelCase = min(_UpperCAmelCase , len(_UpperCAmelCase ) ) trainer.save_model() # Saves the tokenizer too for easy upload trainer.log_metrics('train' , _UpperCAmelCase ) trainer.save_metrics('train' , _UpperCAmelCase ) trainer.save_state() # Evaluation if training_args.do_eval: logger.info('*** Evaluate ***' ) _UpperCAmelCase = trainer.evaluate(eval_dataset=_UpperCAmelCase ) _UpperCAmelCase = data_args.max_eval_samples if data_args.max_eval_samples is not None else len(_UpperCAmelCase ) _UpperCAmelCase = min(_UpperCAmelCase , len(_UpperCAmelCase ) ) trainer.log_metrics('eval' , _UpperCAmelCase ) trainer.save_metrics('eval' , _UpperCAmelCase ) if training_args.do_predict: logger.info('*** Predict ***' ) # Removing the `label` columns because it contains -1 and Trainer won't like that. _UpperCAmelCase = predict_dataset.remove_columns('label' ) _UpperCAmelCase = trainer.predict(_UpperCAmelCase , metric_key_prefix='predict' ).predictions _UpperCAmelCase = np.argmax(_UpperCAmelCase , axis=1 ) _UpperCAmelCase = os.path.join(training_args.output_dir , 'predict_results_tabfact.txt' ) if trainer.is_world_process_zero(): with open(_UpperCAmelCase , 'w' ) as writer: logger.info('***** Predict Results *****' ) writer.write('index\tprediction\n' ) for index, item in enumerate(_UpperCAmelCase ): _UpperCAmelCase = label_list[item] writer.write(F"{index}\t{item}\n" ) _UpperCAmelCase = {'finetuned_from': model_args.model_name_or_path, 'tasks': 'text-classification'} if training_args.push_to_hub: trainer.push_to_hub(**_UpperCAmelCase ) else: trainer.create_model_card(**_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[Any] ) -> Optional[Any]: '''simple docstring''' # For xla_spawn (TPUs) main() if __name__ == "__main__": main()
339
1
import inspect import unittest import numpy as np from transformers import ViTConfig, is_flax_available from transformers.testing_utils import require_flax, slow from ...test_configuration_common import ConfigTester from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor if is_flax_available(): import jax from transformers.models.vit.modeling_flax_vit import FlaxViTForImageClassification, FlaxViTModel class __lowerCAmelCase ( unittest.TestCase ): def __init__( self : Union[str, Any] , A : str , A : int=13 , A : List[str]=30 , A : Any=2 , A : Any=3 , A : Tuple=True , A : Optional[Any]=True , A : Union[str, Any]=32 , A : int=5 , A : int=4 , A : Tuple=37 , A : Optional[int]="gelu" , A : List[str]=0.1 , A : Tuple=0.1 , A : Dict=10 , A : Dict=0.0_2 , ) -> List[str]: """simple docstring""" _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = image_size _UpperCAmelCase = patch_size _UpperCAmelCase = num_channels _UpperCAmelCase = is_training _UpperCAmelCase = use_labels _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = type_sequence_label_size _UpperCAmelCase = initializer_range # in ViT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token) _UpperCAmelCase = (image_size // patch_size) ** 2 _UpperCAmelCase = num_patches + 1 def _lowerCamelCase ( self : Optional[int]) -> int: """simple docstring""" _UpperCAmelCase = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]) _UpperCAmelCase = ViTConfig( image_size=self.image_size , patch_size=self.patch_size , num_channels=self.num_channels , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , is_decoder=A , initializer_range=self.initializer_range , ) return config, pixel_values def _lowerCamelCase ( self : List[str] , A : List[str] , A : Dict) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = FlaxViTModel(config=A) _UpperCAmelCase = model(A) # expected sequence length = num_patches + 1 (we add 1 for the [CLS] token) _UpperCAmelCase = (self.image_size, self.image_size) _UpperCAmelCase = (self.patch_size, self.patch_size) _UpperCAmelCase = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0]) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, num_patches + 1, self.hidden_size)) def _lowerCamelCase ( self : Tuple , A : Dict , A : Optional[Any]) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = self.type_sequence_label_size _UpperCAmelCase = FlaxViTForImageClassification(config=A) _UpperCAmelCase = model(A) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.type_sequence_label_size)) # test greyscale images _UpperCAmelCase = 1 _UpperCAmelCase = FlaxViTForImageClassification(A) _UpperCAmelCase = floats_tensor([self.batch_size, 1, self.image_size, self.image_size]) _UpperCAmelCase = model(A) def _lowerCamelCase ( self : Tuple) -> str: """simple docstring""" _UpperCAmelCase = self.prepare_config_and_inputs() ( ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ) = config_and_inputs _UpperCAmelCase = {'pixel_values': pixel_values} return config, inputs_dict @require_flax class __lowerCAmelCase ( A , unittest.TestCase ): UpperCamelCase = (FlaxViTModel, FlaxViTForImageClassification) if is_flax_available() else () def _lowerCamelCase ( self : List[str]) -> None: """simple docstring""" _UpperCAmelCase = FlaxViTModelTester(self) _UpperCAmelCase = ConfigTester(self , config_class=A , has_text_modality=A , hidden_size=37) def _lowerCamelCase ( self : int) -> Any: """simple docstring""" self.config_tester.run_common_tests() def _lowerCamelCase ( self : Optional[Any]) -> List[Any]: """simple docstring""" _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*A) def _lowerCamelCase ( self : Optional[int]) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*A) def _lowerCamelCase ( self : Tuple) -> Optional[Any]: """simple docstring""" _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(A) _UpperCAmelCase = inspect.signature(model.__call__) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCAmelCase = [*signature.parameters.keys()] _UpperCAmelCase = ['pixel_values'] self.assertListEqual(arg_names[:1] , A) def _lowerCamelCase ( self : List[str]) -> List[str]: """simple docstring""" _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: with self.subTest(model_class.__name__): _UpperCAmelCase = self._prepare_for_class(A , A) _UpperCAmelCase = model_class(A) @jax.jit def model_jitted(A : Optional[Any] , **A : Tuple): return model(pixel_values=A , **A) with self.subTest('JIT Enabled'): _UpperCAmelCase = model_jitted(**A).to_tuple() with self.subTest('JIT Disabled'): with jax.disable_jit(): _UpperCAmelCase = model_jitted(**A).to_tuple() self.assertEqual(len(A) , len(A)) for jitted_output, output in zip(A , A): self.assertEqual(jitted_output.shape , output.shape) @slow def _lowerCamelCase ( self : List[Any]) -> List[Any]: """simple docstring""" for model_class_name in self.all_model_classes: _UpperCAmelCase = model_class_name.from_pretrained('google/vit-base-patch16-224') _UpperCAmelCase = model(np.ones((1, 3, 2_24, 2_24))) self.assertIsNotNone(A)
339
# This code is adapted from OpenAI's release # https://github.com/openai/human-eval/blob/master/human_eval/execution.py import contextlib import faulthandler import io import multiprocessing import os import platform import signal import tempfile def A ( _UpperCAmelCase : Union[str, Any] , _UpperCAmelCase : Dict , _UpperCAmelCase : Dict , _UpperCAmelCase : Dict ) -> Any: '''simple docstring''' _UpperCAmelCase = multiprocessing.Manager() _UpperCAmelCase = manager.list() _UpperCAmelCase = multiprocessing.Process(target=_UpperCAmelCase , args=(check_program, result, timeout) ) p.start() p.join(timeout=timeout + 1 ) if p.is_alive(): p.kill() if not result: result.append('timed out' ) return { "task_id": task_id, "passed": result[0] == "passed", "result": result[0], "completion_id": completion_id, } def A ( _UpperCAmelCase : str , _UpperCAmelCase : List[str] , _UpperCAmelCase : Dict ) -> Optional[int]: '''simple docstring''' with create_tempdir(): # These system calls are needed when cleaning up tempdir. import os import shutil _UpperCAmelCase = shutil.rmtree _UpperCAmelCase = os.rmdir _UpperCAmelCase = os.chdir # Disable functionalities that can make destructive changes to the test. reliability_guard() # Run program. try: _UpperCAmelCase = {} with swallow_io(): with time_limit(_UpperCAmelCase ): exec(_UpperCAmelCase , _UpperCAmelCase ) result.append('passed' ) except TimeoutException: result.append('timed out' ) except BaseException as e: result.append(F"failed: {e}" ) # Needed for cleaning up. _UpperCAmelCase = rmtree _UpperCAmelCase = rmdir _UpperCAmelCase = chdir @contextlib.contextmanager def A ( _UpperCAmelCase : Union[str, Any] ) -> Any: '''simple docstring''' def signal_handler(_UpperCAmelCase : List[Any] , _UpperCAmelCase : Dict ): raise TimeoutException('Timed out!' ) signal.setitimer(signal.ITIMER_REAL , _UpperCAmelCase ) signal.signal(signal.SIGALRM , _UpperCAmelCase ) try: yield finally: signal.setitimer(signal.ITIMER_REAL , 0 ) @contextlib.contextmanager def A ( ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = WriteOnlyStringIO() with contextlib.redirect_stdout(_UpperCAmelCase ): with contextlib.redirect_stderr(_UpperCAmelCase ): with redirect_stdin(_UpperCAmelCase ): yield @contextlib.contextmanager def A ( ) -> Any: '''simple docstring''' with tempfile.TemporaryDirectory() as dirname: with chdir(_UpperCAmelCase ): yield dirname class __lowerCAmelCase ( A ): pass class __lowerCAmelCase ( io.StringIO ): def _lowerCamelCase ( self : Tuple , *A : str , **A : Any) -> Any: """simple docstring""" raise OSError def _lowerCamelCase ( self : List[str] , *A : Optional[Any] , **A : Optional[Any]) -> Optional[int]: """simple docstring""" raise OSError def _lowerCamelCase ( self : str , *A : List[str] , **A : List[Any]) -> Union[str, Any]: """simple docstring""" raise OSError def _lowerCamelCase ( self : Union[str, Any] , *A : Optional[Any] , **A : List[str]) -> Optional[int]: """simple docstring""" return False class __lowerCAmelCase ( contextlib._RedirectStream ): # type: ignore UpperCamelCase = '''stdin''' @contextlib.contextmanager def A ( _UpperCAmelCase : List[Any] ) -> Dict: '''simple docstring''' if root == ".": yield return _UpperCAmelCase = os.getcwd() os.chdir(_UpperCAmelCase ) try: yield except BaseException as exc: raise exc finally: os.chdir(_UpperCAmelCase ) def A ( _UpperCAmelCase : List[str]=None ) -> Any: '''simple docstring''' if maximum_memory_bytes is not None: import resource resource.setrlimit(resource.RLIMIT_AS , (maximum_memory_bytes, maximum_memory_bytes) ) resource.setrlimit(resource.RLIMIT_DATA , (maximum_memory_bytes, maximum_memory_bytes) ) if not platform.uname().system == "Darwin": resource.setrlimit(resource.RLIMIT_STACK , (maximum_memory_bytes, maximum_memory_bytes) ) faulthandler.disable() import builtins _UpperCAmelCase = None _UpperCAmelCase = None import os _UpperCAmelCase = '1' _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None import shutil _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None import subprocess _UpperCAmelCase = None # type: ignore _UpperCAmelCase = None import sys _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None
339
1
from dataclasses import dataclass from typing import Optional import torch from torch import nn from ..configuration_utils import ConfigMixin, register_to_config from ..utils import BaseOutput from .attention import BasicTransformerBlock from .modeling_utils import ModelMixin @dataclass class __lowerCAmelCase ( A ): UpperCamelCase = 42 class __lowerCAmelCase ( A , A ): @register_to_config def __init__( self : Tuple , A : int = 16 , A : int = 88 , A : Optional[int] = None , A : Optional[int] = None , A : int = 1 , A : float = 0.0 , A : int = 32 , A : Optional[int] = None , A : bool = False , A : Optional[int] = None , A : str = "geglu" , A : bool = True , A : bool = True , ) -> Optional[int]: """simple docstring""" super().__init__() _UpperCAmelCase = num_attention_heads _UpperCAmelCase = attention_head_dim _UpperCAmelCase = num_attention_heads * attention_head_dim _UpperCAmelCase = in_channels _UpperCAmelCase = torch.nn.GroupNorm(num_groups=A , num_channels=A , eps=1E-6 , affine=A) _UpperCAmelCase = nn.Linear(A , A) # 3. Define transformers blocks _UpperCAmelCase = nn.ModuleList( [ BasicTransformerBlock( A , A , A , dropout=A , cross_attention_dim=A , activation_fn=A , attention_bias=A , double_self_attention=A , norm_elementwise_affine=A , ) for d in range(A) ]) _UpperCAmelCase = nn.Linear(A , A) def _lowerCamelCase ( self : Any , A : Union[str, Any] , A : List[str]=None , A : Any=None , A : Optional[Any]=None , A : Optional[int]=1 , A : Any=None , A : bool = True , ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = hidden_states.shape _UpperCAmelCase = batch_frames // num_frames _UpperCAmelCase = hidden_states _UpperCAmelCase = hidden_states[None, :].reshape(A , A , A , A , A) _UpperCAmelCase = hidden_states.permute(0 , 2 , 1 , 3 , 4) _UpperCAmelCase = self.norm(A) _UpperCAmelCase = hidden_states.permute(0 , 3 , 4 , 2 , 1).reshape(batch_size * height * width , A , A) _UpperCAmelCase = self.proj_in(A) # 2. Blocks for block in self.transformer_blocks: _UpperCAmelCase = block( A , encoder_hidden_states=A , timestep=A , cross_attention_kwargs=A , class_labels=A , ) # 3. Output _UpperCAmelCase = self.proj_out(A) _UpperCAmelCase = ( hidden_states[None, None, :] .reshape(A , A , A , A , A) .permute(0 , 3 , 4 , 1 , 2) .contiguous() ) _UpperCAmelCase = hidden_states.reshape(A , A , A , A) _UpperCAmelCase = hidden_states + residual if not return_dict: return (output,) return TransformerTemporalModelOutput(sample=A)
339
import asyncio import os import shutil import subprocess import sys import tempfile import unittest from distutils.util import strtobool from functools import partial from pathlib import Path from typing import List, Union from unittest import mock import torch from ..state import AcceleratorState, PartialState from ..utils import ( gather, is_bnb_available, is_comet_ml_available, is_datasets_available, is_deepspeed_available, is_mps_available, is_safetensors_available, is_tensorboard_available, is_torch_version, is_tpu_available, is_transformers_available, is_wandb_available, is_xpu_available, ) def A ( _UpperCAmelCase : Tuple , _UpperCAmelCase : Union[str, Any]=False ) -> str: '''simple docstring''' try: _UpperCAmelCase = os.environ[key] except KeyError: # KEY isn't set, default to `default`. _UpperCAmelCase = default else: # KEY is set, convert it to True or False. try: _UpperCAmelCase = strtobool(_UpperCAmelCase ) except ValueError: # More values are supported, but let's keep the message simple. raise ValueError(F"If set, {key} must be yes or no." ) return _value UpperCAmelCase__ = parse_flag_from_env("RUN_SLOW", default=False) def A ( _UpperCAmelCase : List[str] ) -> List[str]: '''simple docstring''' return unittest.skip('Test was skipped' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Dict ) -> str: '''simple docstring''' return unittest.skipUnless(_run_slow_tests , 'test is slow' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Any ) -> str: '''simple docstring''' return unittest.skipUnless(not torch.cuda.is_available() , 'test requires only a CPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Dict ) -> Dict: '''simple docstring''' return unittest.skipUnless(torch.cuda.is_available() , 'test requires a GPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[Any] ) -> List[Any]: '''simple docstring''' return unittest.skipUnless(is_xpu_available() , 'test requires a XPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[int] ) -> List[str]: '''simple docstring''' return unittest.skipUnless(is_mps_available() , 'test requires a `mps` backend support in `torch`' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Union[str, Any] ) -> List[Any]: '''simple docstring''' return unittest.skipUnless( is_transformers_available() and is_datasets_available() , 'test requires the Hugging Face suite' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : str ) -> str: '''simple docstring''' return unittest.skipUnless(is_bnb_available() , 'test requires the bitsandbytes library' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Union[str, Any] ) -> List[Any]: '''simple docstring''' return unittest.skipUnless(is_tpu_available() , 'test requires TPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[Any] ) -> str: '''simple docstring''' return unittest.skipUnless(torch.cuda.device_count() == 1 , 'test requires a GPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Tuple ) -> int: '''simple docstring''' return unittest.skipUnless(torch.xpu.device_count() == 1 , 'test requires a XPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Any ) -> Optional[int]: '''simple docstring''' return unittest.skipUnless(torch.cuda.device_count() > 1 , 'test requires multiple GPUs' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Tuple ) -> Any: '''simple docstring''' return unittest.skipUnless(torch.xpu.device_count() > 1 , 'test requires multiple XPUs' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Any ) -> Optional[int]: '''simple docstring''' return unittest.skipUnless(is_safetensors_available() , 'test requires safetensors' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : List[Any] ) -> Dict: '''simple docstring''' return unittest.skipUnless(is_deepspeed_available() , 'test requires DeepSpeed' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[int] ) -> str: '''simple docstring''' return unittest.skipUnless(is_torch_version('>=' , '1.12.0' ) , 'test requires torch version >= 1.12.0' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Any=None , _UpperCAmelCase : List[Any]=None ) -> Dict: '''simple docstring''' if test_case is None: return partial(_UpperCAmelCase , version=_UpperCAmelCase ) return unittest.skipUnless(is_torch_version('>=' , _UpperCAmelCase ) , F"test requires torch version >= {version}" )(_UpperCAmelCase ) def A ( _UpperCAmelCase : List[str] ) -> int: '''simple docstring''' return unittest.skipUnless(is_tensorboard_available() , 'test requires Tensorboard' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Union[str, Any] ) -> Union[str, Any]: '''simple docstring''' return unittest.skipUnless(is_wandb_available() , 'test requires wandb' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : List[str] ) -> Optional[int]: '''simple docstring''' return unittest.skipUnless(is_comet_ml_available() , 'test requires comet_ml' )(_UpperCAmelCase ) UpperCAmelCase__ = ( any([is_wandb_available(), is_tensorboard_available()]) and not is_comet_ml_available() ) def A ( _UpperCAmelCase : List[str] ) -> Any: '''simple docstring''' return unittest.skipUnless( _atleast_one_tracker_available , 'test requires at least one tracker to be available and for `comet_ml` to not be installed' , )(_UpperCAmelCase ) class __lowerCAmelCase ( unittest.TestCase ): UpperCamelCase = True @classmethod def _lowerCamelCase ( cls : List[Any]) -> Tuple: """simple docstring""" _UpperCAmelCase = tempfile.mkdtemp() @classmethod def _lowerCamelCase ( cls : Union[str, Any]) -> str: """simple docstring""" if os.path.exists(cls.tmpdir): shutil.rmtree(cls.tmpdir) def _lowerCamelCase ( self : List[str]) -> List[Any]: """simple docstring""" if self.clear_on_setup: for path in Path(self.tmpdir).glob('**/*'): if path.is_file(): path.unlink() elif path.is_dir(): shutil.rmtree(A) class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Dict) -> Tuple: """simple docstring""" super().tearDown() # Reset the state of the AcceleratorState singleton. AcceleratorState._reset_state() PartialState._reset_state() class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Optional[int] , A : Union[mock.Mock, List[mock.Mock]]) -> Tuple: """simple docstring""" _UpperCAmelCase = mocks if isinstance(A , (tuple, list)) else [mocks] for m in self.mocks: m.start() self.addCleanup(m.stop) def A ( _UpperCAmelCase : List[Any] ) -> int: '''simple docstring''' _UpperCAmelCase = AcceleratorState() _UpperCAmelCase = tensor[None].clone().to(state.device ) _UpperCAmelCase = gather(_UpperCAmelCase ).cpu() _UpperCAmelCase = tensor[0].cpu() for i in range(tensors.shape[0] ): if not torch.equal(tensors[i] , _UpperCAmelCase ): return False return True class __lowerCAmelCase : def __init__( self : Optional[Any] , A : Union[str, Any] , A : Optional[int] , A : str) -> Optional[int]: """simple docstring""" _UpperCAmelCase = returncode _UpperCAmelCase = stdout _UpperCAmelCase = stderr async def A ( _UpperCAmelCase : str , _UpperCAmelCase : Optional[int] ) -> Optional[Any]: '''simple docstring''' while True: _UpperCAmelCase = await stream.readline() if line: callback(_UpperCAmelCase ) else: break async def A ( _UpperCAmelCase : Optional[int] , _UpperCAmelCase : List[str]=None , _UpperCAmelCase : str=None , _UpperCAmelCase : str=None , _UpperCAmelCase : Dict=False , _UpperCAmelCase : Union[str, Any]=False ) -> _RunOutput: '''simple docstring''' if echo: print('\nRunning: ' , ' '.join(_UpperCAmelCase ) ) _UpperCAmelCase = await asyncio.create_subprocess_exec( cmd[0] , *cmd[1:] , stdin=_UpperCAmelCase , stdout=asyncio.subprocess.PIPE , stderr=asyncio.subprocess.PIPE , env=_UpperCAmelCase , ) # note: there is a warning for a possible deadlock when using `wait` with huge amounts of data in the pipe # https://docs.python.org/3/library/asyncio-subprocess.html#asyncio.asyncio.subprocess.Process.wait # # If it starts hanging, will need to switch to the following code. The problem is that no data # will be seen until it's done and if it hangs for example there will be no debug info. # out, err = await p.communicate() # return _RunOutput(p.returncode, out, err) _UpperCAmelCase = [] _UpperCAmelCase = [] def tee(_UpperCAmelCase : Union[str, Any] , _UpperCAmelCase : List[Any] , _UpperCAmelCase : str , _UpperCAmelCase : str="" ): _UpperCAmelCase = line.decode('utf-8' ).rstrip() sink.append(_UpperCAmelCase ) if not quiet: print(_UpperCAmelCase , _UpperCAmelCase , file=_UpperCAmelCase ) # XXX: the timeout doesn't seem to make any difference here await asyncio.wait( [ asyncio.create_task(_read_stream(p.stdout , lambda _UpperCAmelCase : tee(_UpperCAmelCase , _UpperCAmelCase , sys.stdout , label='stdout:' ) ) ), asyncio.create_task(_read_stream(p.stderr , lambda _UpperCAmelCase : tee(_UpperCAmelCase , _UpperCAmelCase , sys.stderr , label='stderr:' ) ) ), ] , timeout=_UpperCAmelCase , ) return _RunOutput(await p.wait() , _UpperCAmelCase , _UpperCAmelCase ) def A ( _UpperCAmelCase : str , _UpperCAmelCase : Dict=None , _UpperCAmelCase : str=None , _UpperCAmelCase : str=180 , _UpperCAmelCase : List[Any]=False , _UpperCAmelCase : List[Any]=True ) -> _RunOutput: '''simple docstring''' _UpperCAmelCase = asyncio.get_event_loop() _UpperCAmelCase = loop.run_until_complete( _stream_subprocess(_UpperCAmelCase , env=_UpperCAmelCase , stdin=_UpperCAmelCase , timeout=_UpperCAmelCase , quiet=_UpperCAmelCase , echo=_UpperCAmelCase ) ) _UpperCAmelCase = ' '.join(_UpperCAmelCase ) if result.returncode > 0: _UpperCAmelCase = '\n'.join(result.stderr ) raise RuntimeError( F"'{cmd_str}' failed with returncode {result.returncode}\n\n" F"The combined stderr from workers follows:\n{stderr}" ) return result class __lowerCAmelCase ( A ): pass def A ( _UpperCAmelCase : List[str] , _UpperCAmelCase : str=False ) -> Tuple: '''simple docstring''' try: _UpperCAmelCase = subprocess.check_output(_UpperCAmelCase , stderr=subprocess.STDOUT ) if return_stdout: if hasattr(_UpperCAmelCase , 'decode' ): _UpperCAmelCase = output.decode('utf-8' ) return output except subprocess.CalledProcessError as e: raise SubprocessCallException( F"Command `{' '.join(_UpperCAmelCase )}` failed with the following error:\n\n{e.output.decode()}" ) from e
339
1
def A ( _UpperCAmelCase : int ) -> bool: '''simple docstring''' if not isinstance(_UpperCAmelCase , _UpperCAmelCase ): raise ValueError('check_bouncy() accepts only integer arguments' ) _UpperCAmelCase = str(_UpperCAmelCase ) _UpperCAmelCase = ''.join(sorted(_UpperCAmelCase ) ) return sorted_str_n != str_n and sorted_str_n[::-1] != str_n def A ( _UpperCAmelCase : float = 99 ) -> int: '''simple docstring''' if not 0 < percent < 100: raise ValueError('solution() only accepts values from 0 to 100' ) _UpperCAmelCase = 0 _UpperCAmelCase = 1 while True: if check_bouncy(_UpperCAmelCase ): bouncy_num += 1 if (bouncy_num / num) * 100 >= percent: return num num += 1 if __name__ == "__main__": from doctest import testmod testmod() print(f"""{solution(99)}""")
339
from __future__ import annotations UpperCAmelCase__ = list[list[int]] # assigning initial values to the grid UpperCAmelCase__ = [ [3, 0, 6, 5, 0, 8, 4, 0, 0], [5, 2, 0, 0, 0, 0, 0, 0, 0], [0, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] # a grid with no solution UpperCAmelCase__ = [ [5, 0, 6, 5, 0, 8, 4, 0, 3], [5, 2, 0, 0, 0, 0, 0, 0, 2], [1, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] def A ( _UpperCAmelCase : Matrix , _UpperCAmelCase : int , _UpperCAmelCase : int , _UpperCAmelCase : int ) -> bool: '''simple docstring''' for i in range(9 ): if grid[row][i] == n or grid[i][column] == n: return False for i in range(3 ): for j in range(3 ): if grid[(row - row % 3) + i][(column - column % 3) + j] == n: return False return True def A ( _UpperCAmelCase : Matrix ) -> tuple[int, int] | None: '''simple docstring''' for i in range(9 ): for j in range(9 ): if grid[i][j] == 0: return i, j return None def A ( _UpperCAmelCase : Matrix ) -> Matrix | None: '''simple docstring''' if location := find_empty_location(_UpperCAmelCase ): _UpperCAmelCase , _UpperCAmelCase = location else: # If the location is ``None``, then the grid is solved. return grid for digit in range(1 , 10 ): if is_safe(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ): _UpperCAmelCase = digit if sudoku(_UpperCAmelCase ) is not None: return grid _UpperCAmelCase = 0 return None def A ( _UpperCAmelCase : Matrix ) -> None: '''simple docstring''' for row in grid: for cell in row: print(_UpperCAmelCase , end=' ' ) print() if __name__ == "__main__": # make a copy of grid so that you can compare with the unmodified grid for example_grid in (initial_grid, no_solution): print("\nExample grid:\n" + "=" * 20) print_solution(example_grid) print("\nExample grid solution:") UpperCAmelCase__ = sudoku(example_grid) if solution is not None: print_solution(solution) else: print("Cannot find a solution.")
339
1
import shutil import tempfile import unittest from transformers import SPIECE_UNDERLINE, BatchEncoding, MBartaaTokenizer, MBartaaTokenizerFast, is_torch_available from transformers.testing_utils import ( get_tests_dir, nested_simplify, require_sentencepiece, require_tokenizers, require_torch, slow, ) from ...test_tokenization_common import TokenizerTesterMixin UpperCAmelCase__ = get_tests_dir("fixtures/test_sentencepiece.model") if is_torch_available(): from transformers.models.mbart.modeling_mbart import shift_tokens_right UpperCAmelCase__ = 25_0004 UpperCAmelCase__ = 25_0020 @require_sentencepiece @require_tokenizers class __lowerCAmelCase ( A , unittest.TestCase ): UpperCamelCase = MBartaaTokenizer UpperCamelCase = MBartaaTokenizerFast UpperCamelCase = True UpperCamelCase = True def _lowerCamelCase ( self : Optional[Any]) -> Optional[int]: """simple docstring""" super().setUp() # We have a SentencePiece fixture for testing _UpperCAmelCase = MBartaaTokenizer(A , src_lang='en_XX' , tgt_lang='ro_RO' , keep_accents=A) tokenizer.save_pretrained(self.tmpdirname) def _lowerCamelCase ( self : List[str]) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = '<s>' _UpperCAmelCase = 0 self.assertEqual(self.get_tokenizer()._convert_token_to_id(A) , A) self.assertEqual(self.get_tokenizer()._convert_id_to_token(A) , A) def _lowerCamelCase ( self : List[Any]) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = list(self.get_tokenizer().get_vocab().keys()) self.assertEqual(vocab_keys[0] , '<s>') self.assertEqual(vocab_keys[1] , '<pad>') self.assertEqual(vocab_keys[-1] , '<mask>') self.assertEqual(len(A) , 10_54) def _lowerCamelCase ( self : Optional[Any]) -> Optional[int]: """simple docstring""" self.assertEqual(self.get_tokenizer().vocab_size , 10_54) def _lowerCamelCase ( self : Tuple) -> Optional[int]: """simple docstring""" _UpperCAmelCase = MBartaaTokenizer(A , src_lang='en_XX' , tgt_lang='ro_RO' , keep_accents=A) _UpperCAmelCase = tokenizer.tokenize('This is a test') self.assertListEqual(A , ['▁This', '▁is', '▁a', '▁t', 'est']) self.assertListEqual( tokenizer.convert_tokens_to_ids(A) , [value + tokenizer.fairseq_offset for value in [2_85, 46, 10, 1_70, 3_82]] , ) _UpperCAmelCase = tokenizer.tokenize('I was born in 92000, and this is falsé.') self.assertListEqual( A , [SPIECE_UNDERLINE + 'I', SPIECE_UNDERLINE + 'was', SPIECE_UNDERLINE + 'b', 'or', 'n', SPIECE_UNDERLINE + 'in', SPIECE_UNDERLINE + '', '9', '2', '0', '0', '0', ',', SPIECE_UNDERLINE + 'and', SPIECE_UNDERLINE + 'this', SPIECE_UNDERLINE + 'is', SPIECE_UNDERLINE + 'f', 'al', 's', 'é', '.'] , ) _UpperCAmelCase = tokenizer.convert_tokens_to_ids(A) self.assertListEqual( A , [ value + tokenizer.fairseq_offset for value in [8, 21, 84, 55, 24, 19, 7, 2, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 2, 4] ] , ) _UpperCAmelCase = tokenizer.convert_ids_to_tokens(A) self.assertListEqual( A , [SPIECE_UNDERLINE + 'I', SPIECE_UNDERLINE + 'was', SPIECE_UNDERLINE + 'b', 'or', 'n', SPIECE_UNDERLINE + 'in', SPIECE_UNDERLINE + '', '<unk>', '2', '0', '0', '0', ',', SPIECE_UNDERLINE + 'and', SPIECE_UNDERLINE + 'this', SPIECE_UNDERLINE + 'is', SPIECE_UNDERLINE + 'f', 'al', 's', '<unk>', '.'] , ) @slow def _lowerCamelCase ( self : List[str]) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = {'input_ids': [[25_00_04, 1_10_62, 8_27_72, 7, 15, 8_27_72, 5_38, 5_15_29, 2_37, 1_71_98, 12_90, 2_06, 9, 21_51_75, 13_14, 1_36, 1_71_98, 12_90, 2_06, 9, 5_63_59, 42, 12_20_09, 9, 1_64_66, 16, 8_73_44, 45_37, 9, 47_17, 7_83_81, 6, 15_99_58, 7, 15, 2_44_80, 6_18, 4, 5_27, 2_26_93, 54_28, 4, 27_77, 2_44_80, 98_74, 4, 4_35_23, 5_94, 4, 8_03, 1_83_92, 3_31_89, 18, 4, 4_35_23, 2_44_47, 1_23_99, 1_00, 2_49_55, 8_36_58, 96_26, 14_40_57, 15, 8_39, 2_23_35, 16, 1_36, 2_49_55, 8_36_58, 8_34_79, 15, 3_91_02, 7_24, 16, 6_78, 6_45, 27_89, 13_28, 45_89, 42, 12_20_09, 11_57_74, 23, 8_05, 13_28, 4_68_76, 7, 1_36, 5_38_94, 19_40, 4_22_27, 4_11_59, 1_77_21, 8_23, 4_25, 4, 2_75_12, 9_87_22, 2_06, 1_36, 55_31, 49_70, 9_19, 1_73_36, 5, 2], [25_00_04, 2_00_80, 6_18, 83, 8_27_75, 47, 4_79, 9, 15_17, 73, 5_38_94, 3_33, 8_05_81, 11_01_17, 1_88_11, 52_56, 12_95, 51, 15_25_26, 2_97, 79_86, 3_90, 12_44_16, 5_38, 3_54_31, 2_14, 98, 1_50_44, 2_57_37, 1_36, 71_08, 4_37_01, 23, 7_56, 13_53_55, 7, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [25_00_04, 5_81, 6_37_73, 11_94_55, 6, 14_77_97, 8_82_03, 7, 6_45, 70, 21, 32_85, 1_02_69, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]} # noqa: E501 # fmt: on self.tokenizer_integration_test_util( expected_encoding=A , model_name='facebook/mbart-large-50' , revision='d3913889c59cd5c9e456b269c376325eabad57e2' , ) def _lowerCamelCase ( self : Dict) -> Union[str, Any]: """simple docstring""" if not self.test_slow_tokenizer: # as we don't have a slow version, we can't compare the outputs between slow and fast versions return _UpperCAmelCase = (self.rust_tokenizer_class, 'hf-internal-testing/tiny-random-mbart50', {}) for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"): _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained(A , **A) _UpperCAmelCase = self.tokenizer_class.from_pretrained(A , **A) _UpperCAmelCase = tempfile.mkdtemp() _UpperCAmelCase = tokenizer_r.save_pretrained(A) _UpperCAmelCase = tokenizer_p.save_pretrained(A) # Checks it save with the same files + the tokenizer.json file for the fast one self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files)) _UpperCAmelCase = tuple(f for f in tokenizer_r_files if 'tokenizer.json' not in f) self.assertSequenceEqual(A , A) # Checks everything loads correctly in the same way _UpperCAmelCase = tokenizer_r.from_pretrained(A) _UpperCAmelCase = tokenizer_p.from_pretrained(A) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(A , A)) # self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key)) # self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id")) shutil.rmtree(A) # Save tokenizer rust, legacy_format=True _UpperCAmelCase = tempfile.mkdtemp() _UpperCAmelCase = tokenizer_r.save_pretrained(A , legacy_format=A) _UpperCAmelCase = tokenizer_p.save_pretrained(A) # Checks it save with the same files self.assertSequenceEqual(A , A) # Checks everything loads correctly in the same way _UpperCAmelCase = tokenizer_r.from_pretrained(A) _UpperCAmelCase = tokenizer_p.from_pretrained(A) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(A , A)) shutil.rmtree(A) # Save tokenizer rust, legacy_format=False _UpperCAmelCase = tempfile.mkdtemp() _UpperCAmelCase = tokenizer_r.save_pretrained(A , legacy_format=A) _UpperCAmelCase = tokenizer_p.save_pretrained(A) # Checks it saved the tokenizer.json file self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files)) # Checks everything loads correctly in the same way _UpperCAmelCase = tokenizer_r.from_pretrained(A) _UpperCAmelCase = tokenizer_p.from_pretrained(A) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(A , A)) shutil.rmtree(A) @require_torch @require_sentencepiece @require_tokenizers class __lowerCAmelCase ( unittest.TestCase ): UpperCamelCase = '''facebook/mbart-large-50-one-to-many-mmt''' UpperCamelCase = [ ''' UN Chief Says There Is No Military Solution in Syria''', ''' Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for Syria is that "there is no military solution" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.''', ] UpperCamelCase = [ '''Şeful ONU declară că nu există o soluţie militară în Siria''', '''Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei''' ''' pentru Siria este că "nu există o soluţie militară" la conflictul de aproape cinci ani şi că noi arme nu vor''' ''' face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.''', ] UpperCamelCase = [EN_CODE, 8_2_7_4, 1_2_7_8_7_3, 2_5_9_1_6, 7, 8_6_2_2, 2_0_7_1, 4_3_8, 6_7_4_8_5, 5_3, 1_8_7_8_9_5, 2_3, 5_1_7_1_2, 2] @classmethod def _lowerCamelCase ( cls : Dict) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = MBartaaTokenizer.from_pretrained( cls.checkpoint_name , src_lang='en_XX' , tgt_lang='ro_RO') _UpperCAmelCase = 1 return cls def _lowerCamelCase ( self : Tuple) -> List[Any]: """simple docstring""" self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ar_AR'] , 25_00_01) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['en_EN'] , 25_00_04) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ro_RO'] , 25_00_20) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['mr_IN'] , 25_00_38) def _lowerCamelCase ( self : Dict) -> Optional[int]: """simple docstring""" _UpperCAmelCase = self.tokenizer.batch_encode_plus(self.src_text).input_ids[0] self.assertListEqual(self.expected_src_tokens , A) def _lowerCamelCase ( self : Optional[Any]) -> Union[str, Any]: """simple docstring""" self.assertIn(A , self.tokenizer.all_special_ids) _UpperCAmelCase = [RO_CODE, 8_84, 90_19, 96, 9, 9_16, 8_67_92, 36, 1_87_43, 1_55_96, 5, 2] _UpperCAmelCase = self.tokenizer.decode(A , skip_special_tokens=A) _UpperCAmelCase = self.tokenizer.decode(generated_ids[1:] , skip_special_tokens=A) self.assertEqual(A , A) self.assertNotIn(self.tokenizer.eos_token , A) def _lowerCamelCase ( self : Optional[Any]) -> Dict: """simple docstring""" _UpperCAmelCase = ['this is gunna be a long sentence ' * 20] assert isinstance(src_text[0] , A) _UpperCAmelCase = 10 _UpperCAmelCase = self.tokenizer(A , max_length=A , truncation=A).input_ids[0] self.assertEqual(ids[0] , A) self.assertEqual(ids[-1] , 2) self.assertEqual(len(A) , A) def _lowerCamelCase ( self : List[str]) -> Optional[Any]: """simple docstring""" self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['<mask>', 'ar_AR']) , [25_00_53, 25_00_01]) def _lowerCamelCase ( self : Optional[int]) -> Tuple: """simple docstring""" _UpperCAmelCase = tempfile.mkdtemp() _UpperCAmelCase = self.tokenizer.fairseq_tokens_to_ids self.tokenizer.save_pretrained(A) _UpperCAmelCase = MBartaaTokenizer.from_pretrained(A) self.assertDictEqual(new_tok.fairseq_tokens_to_ids , A) @require_torch def _lowerCamelCase ( self : Optional[Any]) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = self.tokenizer(self.src_text , text_target=self.tgt_text , padding=A , return_tensors='pt') _UpperCAmelCase = shift_tokens_right(batch['labels'] , self.tokenizer.pad_token_id) # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4 assert batch.input_ids[1][0] == EN_CODE assert batch.input_ids[1][-1] == 2 assert batch.labels[1][0] == RO_CODE assert batch.labels[1][-1] == 2 assert batch.decoder_input_ids[1][:2].tolist() == [2, RO_CODE] @require_torch def _lowerCamelCase ( self : Any) -> List[Any]: """simple docstring""" _UpperCAmelCase = self.tokenizer( self.src_text , text_target=self.tgt_text , padding=A , truncation=A , max_length=len(self.expected_src_tokens) , return_tensors='pt' , ) _UpperCAmelCase = shift_tokens_right(batch['labels'] , self.tokenizer.pad_token_id) self.assertIsInstance(A , A) self.assertEqual((2, 14) , batch.input_ids.shape) self.assertEqual((2, 14) , batch.attention_mask.shape) _UpperCAmelCase = batch.input_ids.tolist()[0] self.assertListEqual(self.expected_src_tokens , A) self.assertEqual(2 , batch.decoder_input_ids[0, 0]) # decoder_start_token_id # Test that special tokens are reset self.assertEqual(self.tokenizer.prefix_tokens , [EN_CODE]) self.assertEqual(self.tokenizer.suffix_tokens , [self.tokenizer.eos_token_id]) def _lowerCamelCase ( self : Optional[Any]) -> List[Any]: """simple docstring""" _UpperCAmelCase = self.tokenizer(self.src_text , padding=A , truncation=A , max_length=3 , return_tensors='pt') _UpperCAmelCase = self.tokenizer( text_target=self.tgt_text , padding=A , truncation=A , max_length=10 , return_tensors='pt') _UpperCAmelCase = targets['input_ids'] _UpperCAmelCase = shift_tokens_right(A , self.tokenizer.pad_token_id) self.assertEqual(batch.input_ids.shape[1] , 3) self.assertEqual(batch.decoder_input_ids.shape[1] , 10) @require_torch def _lowerCamelCase ( self : List[str]) -> Tuple: """simple docstring""" _UpperCAmelCase = self.tokenizer._build_translation_inputs( 'A test' , return_tensors='pt' , src_lang='en_XX' , tgt_lang='ar_AR') self.assertEqual( nested_simplify(A) , { # en_XX, A, test, EOS 'input_ids': [[25_00_04, 62, 30_34, 2]], 'attention_mask': [[1, 1, 1, 1]], # ar_AR 'forced_bos_token_id': 25_00_01, } , )
339
import numpy as np from nltk.translate import meteor_score import datasets from datasets.config import importlib_metadata, version UpperCAmelCase__ = version.parse(importlib_metadata.version("nltk")) if NLTK_VERSION >= version.Version("3.6.4"): from nltk import word_tokenize UpperCAmelCase__ = "\\n@inproceedings{banarjee2005,\n title = {{METEOR}: An Automatic Metric for {MT} Evaluation with Improved Correlation with Human Judgments},\n author = {Banerjee, Satanjeev and Lavie, Alon},\n booktitle = {Proceedings of the {ACL} Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization},\n month = jun,\n year = {2005},\n address = {Ann Arbor, Michigan},\n publisher = {Association for Computational Linguistics},\n url = {https://www.aclweb.org/anthology/W05-0909},\n pages = {65--72},\n}\n" UpperCAmelCase__ = "\\nMETEOR, an automatic metric for machine translation evaluation\nthat is based on a generalized concept of unigram matching between the\nmachine-produced translation and human-produced reference translations.\nUnigrams can be matched based on their surface forms, stemmed forms,\nand meanings; furthermore, METEOR can be easily extended to include more\nadvanced matching strategies. Once all generalized unigram matches\nbetween the two strings have been found, METEOR computes a score for\nthis matching using a combination of unigram-precision, unigram-recall, and\na measure of fragmentation that is designed to directly capture how\nwell-ordered the matched words in the machine translation are in relation\nto the reference.\n\nMETEOR gets an R correlation value of 0.347 with human evaluation on the Arabic\ndata and 0.331 on the Chinese data. This is shown to be an improvement on\nusing simply unigram-precision, unigram-recall and their harmonic F1\ncombination.\n" UpperCAmelCase__ = "\nComputes METEOR score of translated segments against one or more references.\nArgs:\n predictions: list of predictions to score. Each prediction\n should be a string with tokens separated by spaces.\n references: list of reference for each prediction. Each\n reference should be a string with tokens separated by spaces.\n alpha: Parameter for controlling relative weights of precision and recall. default: 0.9\n beta: Parameter for controlling shape of penalty as a function of fragmentation. default: 3\n gamma: Relative weight assigned to fragmentation penalty. default: 0.5\nReturns:\n 'meteor': meteor score.\nExamples:\n\n >>> meteor = datasets.load_metric('meteor')\n >>> predictions = [\"It is a guide to action which ensures that the military always obeys the commands of the party\"]\n >>> references = [\"It is a guide to action that ensures that the military will forever heed Party commands\"]\n >>> results = meteor.compute(predictions=predictions, references=references)\n >>> print(round(results[\"meteor\"], 4))\n 0.6944\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class __lowerCAmelCase ( datasets.Metric ): def _lowerCamelCase ( self : List[Any]) -> List[Any]: """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': datasets.Value('string' , id='sequence'), 'references': datasets.Value('string' , id='sequence'), }) , codebase_urls=['https://github.com/nltk/nltk/blob/develop/nltk/translate/meteor_score.py'] , reference_urls=[ 'https://www.nltk.org/api/nltk.translate.html#module-nltk.translate.meteor_score', 'https://en.wikipedia.org/wiki/METEOR', ] , ) def _lowerCamelCase ( self : Optional[Any] , A : List[str]) -> List[Any]: """simple docstring""" import nltk nltk.download('wordnet') if NLTK_VERSION >= version.Version('3.6.5'): nltk.download('punkt') if NLTK_VERSION >= version.Version('3.6.6'): nltk.download('omw-1.4') def _lowerCamelCase ( self : Optional[Any] , A : Tuple , A : Optional[int] , A : List[Any]=0.9 , A : Optional[Any]=3 , A : Optional[int]=0.5) -> Any: """simple docstring""" if NLTK_VERSION >= version.Version('3.6.5'): _UpperCAmelCase = [ meteor_score.single_meteor_score( word_tokenize(A) , word_tokenize(A) , alpha=A , beta=A , gamma=A) for ref, pred in zip(A , A) ] else: _UpperCAmelCase = [ meteor_score.single_meteor_score(A , A , alpha=A , beta=A , gamma=A) for ref, pred in zip(A , A) ] return {"meteor": np.mean(A)}
339
1
from functools import reduce UpperCAmelCase__ = ( "73167176531330624919225119674426574742355349194934" "96983520312774506326239578318016984801869478851843" "85861560789112949495459501737958331952853208805511" "12540698747158523863050715693290963295227443043557" "66896648950445244523161731856403098711121722383113" "62229893423380308135336276614282806444486645238749" "30358907296290491560440772390713810515859307960866" "70172427121883998797908792274921901699720888093776" "65727333001053367881220235421809751254540594752243" "52584907711670556013604839586446706324415722155397" "53697817977846174064955149290862569321978468622482" "83972241375657056057490261407972968652414535100474" "82166370484403199890008895243450658541227588666881" "16427171479924442928230863465674813919123162824586" "17866458359124566529476545682848912883142607690042" "24219022671055626321111109370544217506941658960408" "07198403850962455444362981230987879927244284909188" "84580156166097919133875499200524063689912560717606" "05886116467109405077541002256983155200055935729725" "71636269561882670428252483600823257530420752963450" ) def A ( _UpperCAmelCase : str = N ) -> int: '''simple docstring''' return max( # mypy cannot properly interpret reduce int(reduce(lambda _UpperCAmelCase , _UpperCAmelCase : str(int(_UpperCAmelCase ) * int(_UpperCAmelCase ) ) , n[i : i + 13] ) ) for i in range(len(_UpperCAmelCase ) - 12 ) ) if __name__ == "__main__": print(f"""{solution() = }""")
339
import argparse import hashlib import os import urllib import warnings import torch from torch import nn from tqdm import tqdm from transformers import WhisperConfig, WhisperForConditionalGeneration UpperCAmelCase__ = { "tiny.en": "https://openaipublic.azureedge.net/main/whisper/models/d3dd57d32accea0b295c96e26691aa14d8822fac7d9d27d5dc00b4ca2826dd03/tiny.en.pt", "tiny": "https://openaipublic.azureedge.net/main/whisper/models/65147644a518d12f04e32d6f3b26facc3f8dd46e5390956a9424a650c0ce22b9/tiny.pt", "base.en": "https://openaipublic.azureedge.net/main/whisper/models/25a8566e1d0c1e2231d1c762132cd20e0f96a85d16145c3a00adf5d1ac670ead/base.en.pt", "base": "https://openaipublic.azureedge.net/main/whisper/models/ed3a0b6b1c0edf879ad9b11b1af5a0e6ab5db9205f891f668f8b0e6c6326e34e/base.pt", "small.en": "https://openaipublic.azureedge.net/main/whisper/models/f953ad0fd29cacd07d5a9eda5624af0f6bcf2258be67c92b79389873d91e0872/small.en.pt", "small": "https://openaipublic.azureedge.net/main/whisper/models/9ecf779972d90ba49c06d968637d720dd632c55bbf19d441fb42bf17a411e794/small.pt", "medium.en": "https://openaipublic.azureedge.net/main/whisper/models/d7440d1dc186f76616474e0ff0b3b6b879abc9d1a4926b7adfa41db2d497ab4f/medium.en.pt", "medium": "https://openaipublic.azureedge.net/main/whisper/models/345ae4da62f9b3d59415adc60127b97c714f32e89e936602e85993674d08dcb1/medium.pt", "large": "https://openaipublic.azureedge.net/main/whisper/models/e4b87e7e0bf463eb8e6956e646f1e277e901512310def2c24bf0e11bd3c28e9a/large.pt", "large-v2": "https://openaipublic.azureedge.net/main/whisper/models/81f7c96c852ee8fc832187b0132e569d6c3065a3252ed18e56effd0b6a73e524/large-v2.pt", } def A ( _UpperCAmelCase : Optional[int] ) -> str: '''simple docstring''' _UpperCAmelCase = ['layers', 'blocks'] for k in ignore_keys: state_dict.pop(_UpperCAmelCase , _UpperCAmelCase ) UpperCAmelCase__ = { "blocks": "layers", "mlp.0": "fc1", "mlp.2": "fc2", "mlp_ln": "final_layer_norm", ".attn.query": ".self_attn.q_proj", ".attn.key": ".self_attn.k_proj", ".attn.value": ".self_attn.v_proj", ".attn_ln": ".self_attn_layer_norm", ".attn.out": ".self_attn.out_proj", ".cross_attn.query": ".encoder_attn.q_proj", ".cross_attn.key": ".encoder_attn.k_proj", ".cross_attn.value": ".encoder_attn.v_proj", ".cross_attn_ln": ".encoder_attn_layer_norm", ".cross_attn.out": ".encoder_attn.out_proj", "decoder.ln.": "decoder.layer_norm.", "encoder.ln.": "encoder.layer_norm.", "token_embedding": "embed_tokens", "encoder.positional_embedding": "encoder.embed_positions.weight", "decoder.positional_embedding": "decoder.embed_positions.weight", "ln_post": "layer_norm", } def A ( _UpperCAmelCase : Dict ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = list(s_dict.keys() ) for key in keys: _UpperCAmelCase = key for k, v in WHISPER_MAPPING.items(): if k in key: _UpperCAmelCase = new_key.replace(_UpperCAmelCase , _UpperCAmelCase ) print(F"{key} -> {new_key}" ) _UpperCAmelCase = s_dict.pop(_UpperCAmelCase ) return s_dict def A ( _UpperCAmelCase : List[Any] ) -> Union[str, Any]: '''simple docstring''' _UpperCAmelCase , _UpperCAmelCase = emb.weight.shape _UpperCAmelCase = nn.Linear(_UpperCAmelCase , _UpperCAmelCase , bias=_UpperCAmelCase ) _UpperCAmelCase = emb.weight.data return lin_layer def A ( _UpperCAmelCase : str , _UpperCAmelCase : str ) -> bytes: '''simple docstring''' os.makedirs(_UpperCAmelCase , exist_ok=_UpperCAmelCase ) _UpperCAmelCase = os.path.basename(_UpperCAmelCase ) _UpperCAmelCase = url.split('/' )[-2] _UpperCAmelCase = os.path.join(_UpperCAmelCase , _UpperCAmelCase ) if os.path.exists(_UpperCAmelCase ) and not os.path.isfile(_UpperCAmelCase ): raise RuntimeError(F"{download_target} exists and is not a regular file" ) if os.path.isfile(_UpperCAmelCase ): _UpperCAmelCase = open(_UpperCAmelCase , 'rb' ).read() if hashlib.shaaaa(_UpperCAmelCase ).hexdigest() == expected_shaaaa: return model_bytes else: warnings.warn(F"{download_target} exists, but the SHA256 checksum does not match; re-downloading the file" ) with urllib.request.urlopen(_UpperCAmelCase ) as source, open(_UpperCAmelCase , 'wb' ) as output: with tqdm( total=int(source.info().get('Content-Length' ) ) , ncols=80 , unit='iB' , unit_scale=_UpperCAmelCase , unit_divisor=1_024 ) as loop: while True: _UpperCAmelCase = source.read(8_192 ) if not buffer: break output.write(_UpperCAmelCase ) loop.update(len(_UpperCAmelCase ) ) _UpperCAmelCase = open(_UpperCAmelCase , 'rb' ).read() if hashlib.shaaaa(_UpperCAmelCase ).hexdigest() != expected_shaaaa: raise RuntimeError( 'Model has been downloaded but the SHA256 checksum does not not match. Please retry loading the model.' ) return model_bytes def A ( _UpperCAmelCase : List[Any] , _UpperCAmelCase : Any ) -> Optional[int]: '''simple docstring''' if ".pt" not in checkpoint_path: _UpperCAmelCase = _download(_MODELS[checkpoint_path] ) else: _UpperCAmelCase = torch.load(_UpperCAmelCase , map_location='cpu' ) _UpperCAmelCase = original_checkpoint['dims'] _UpperCAmelCase = original_checkpoint['model_state_dict'] _UpperCAmelCase = state_dict['decoder.token_embedding.weight'] remove_ignore_keys_(_UpperCAmelCase ) rename_keys(_UpperCAmelCase ) _UpperCAmelCase = True _UpperCAmelCase = state_dict['decoder.layers.0.fc1.weight'].shape[0] _UpperCAmelCase = WhisperConfig( vocab_size=dimensions['n_vocab'] , encoder_ffn_dim=_UpperCAmelCase , decoder_ffn_dim=_UpperCAmelCase , num_mel_bins=dimensions['n_mels'] , d_model=dimensions['n_audio_state'] , max_target_positions=dimensions['n_text_ctx'] , encoder_layers=dimensions['n_audio_layer'] , encoder_attention_heads=dimensions['n_audio_head'] , decoder_layers=dimensions['n_text_layer'] , decoder_attention_heads=dimensions['n_text_state'] , max_source_positions=dimensions['n_audio_ctx'] , ) _UpperCAmelCase = WhisperForConditionalGeneration(_UpperCAmelCase ) _UpperCAmelCase , _UpperCAmelCase = model.model.load_state_dict(_UpperCAmelCase , strict=_UpperCAmelCase ) if len(_UpperCAmelCase ) > 0 and not set(_UpperCAmelCase ) <= { "encoder.embed_positions.weights", "decoder.embed_positions.weights", }: raise ValueError( 'Only `encoder.embed_positions.weights` and `decoder.embed_positions.weights` are allowed to be missing,' F" but all the following weights are missing {missing}" ) if tie_embeds: _UpperCAmelCase = make_linear_from_emb(model.model.decoder.embed_tokens ) else: _UpperCAmelCase = proj_out_weights model.save_pretrained(_UpperCAmelCase ) if __name__ == "__main__": UpperCAmelCase__ = argparse.ArgumentParser() # # Required parameters parser.add_argument("--checkpoint_path", type=str, help="Patht to the downloaded checkpoints") parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.") UpperCAmelCase__ = parser.parse_args() convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)
339
1
from __future__ import annotations from sys import maxsize from typing import Generic, TypeVar UpperCAmelCase__ = TypeVar("T") def A ( _UpperCAmelCase : int ) -> int: '''simple docstring''' return (position - 1) // 2 def A ( _UpperCAmelCase : int ) -> int: '''simple docstring''' return (2 * position) + 1 def A ( _UpperCAmelCase : int ) -> int: '''simple docstring''' return (2 * position) + 2 class __lowerCAmelCase ( Generic[T] ): def __init__( self : str) -> None: """simple docstring""" _UpperCAmelCase = [] _UpperCAmelCase = {} _UpperCAmelCase = 0 def __len__( self : Optional[int]) -> int: """simple docstring""" return self.elements def __repr__( self : Dict) -> str: """simple docstring""" return str(self.heap) def _lowerCamelCase ( self : Dict) -> bool: """simple docstring""" return self.elements == 0 def _lowerCamelCase ( self : List[str] , A : T , A : int) -> None: """simple docstring""" self.heap.append((elem, weight)) _UpperCAmelCase = self.elements self.elements += 1 self._bubble_up(A) def _lowerCamelCase ( self : Union[str, Any]) -> T: """simple docstring""" if self.elements > 1: self._swap_nodes(0 , self.elements - 1) _UpperCAmelCase , _UpperCAmelCase = self.heap.pop() del self.position_map[elem] self.elements -= 1 if self.elements > 0: _UpperCAmelCase , _UpperCAmelCase = self.heap[0] self._bubble_down(A) return elem def _lowerCamelCase ( self : Tuple , A : T , A : int) -> None: """simple docstring""" _UpperCAmelCase = self.position_map[elem] _UpperCAmelCase = (elem, weight) if position > 0: _UpperCAmelCase = get_parent_position(A) _UpperCAmelCase , _UpperCAmelCase = self.heap[parent_position] if parent_weight > weight: self._bubble_up(A) else: self._bubble_down(A) else: self._bubble_down(A) def _lowerCamelCase ( self : Union[str, Any] , A : T) -> None: """simple docstring""" _UpperCAmelCase = self.position_map[elem] if curr_pos == 0: return None _UpperCAmelCase = get_parent_position(A) _UpperCAmelCase , _UpperCAmelCase = self.heap[curr_pos] _UpperCAmelCase , _UpperCAmelCase = self.heap[parent_position] if parent_weight > weight: self._swap_nodes(A , A) return self._bubble_up(A) return None def _lowerCamelCase ( self : List[str] , A : T) -> None: """simple docstring""" _UpperCAmelCase = self.position_map[elem] _UpperCAmelCase , _UpperCAmelCase = self.heap[curr_pos] _UpperCAmelCase = get_child_left_position(A) _UpperCAmelCase = get_child_right_position(A) if child_left_position < self.elements and child_right_position < self.elements: _UpperCAmelCase , _UpperCAmelCase = self.heap[child_left_position] _UpperCAmelCase , _UpperCAmelCase = self.heap[child_right_position] if child_right_weight < child_left_weight and child_right_weight < weight: self._swap_nodes(A , A) return self._bubble_down(A) if child_left_position < self.elements: _UpperCAmelCase , _UpperCAmelCase = self.heap[child_left_position] if child_left_weight < weight: self._swap_nodes(A , A) return self._bubble_down(A) else: return None if child_right_position < self.elements: _UpperCAmelCase , _UpperCAmelCase = self.heap[child_right_position] if child_right_weight < weight: self._swap_nodes(A , A) return self._bubble_down(A) return None def _lowerCamelCase ( self : Any , A : int , A : int) -> None: """simple docstring""" _UpperCAmelCase = self.heap[nodea_pos][0] _UpperCAmelCase = self.heap[nodea_pos][0] _UpperCAmelCase , _UpperCAmelCase = ( self.heap[nodea_pos], self.heap[nodea_pos], ) _UpperCAmelCase = nodea_pos _UpperCAmelCase = nodea_pos class __lowerCAmelCase ( Generic[T] ): def __init__( self : List[str]) -> None: """simple docstring""" _UpperCAmelCase = {} _UpperCAmelCase = 0 def __repr__( self : Tuple) -> str: """simple docstring""" return str(self.connections) def __len__( self : Optional[Any]) -> int: """simple docstring""" return self.nodes def _lowerCamelCase ( self : Tuple , A : T) -> None: """simple docstring""" if node not in self.connections: _UpperCAmelCase = {} self.nodes += 1 def _lowerCamelCase ( self : Dict , A : T , A : T , A : int) -> None: """simple docstring""" self.add_node(A) self.add_node(A) _UpperCAmelCase = weight _UpperCAmelCase = weight def A ( _UpperCAmelCase : GraphUndirectedWeighted[T] , ) -> tuple[dict[T, int], dict[T, T | None]]: '''simple docstring''' _UpperCAmelCase = {node: maxsize for node in graph.connections} _UpperCAmelCase = {node: None for node in graph.connections} _UpperCAmelCase = MinPriorityQueue() for node, weight in dist.items(): priority_queue.push(_UpperCAmelCase , _UpperCAmelCase ) if priority_queue.is_empty(): return dist, parent # initialization _UpperCAmelCase = priority_queue.extract_min() _UpperCAmelCase = 0 for neighbour in graph.connections[node]: if dist[neighbour] > dist[node] + graph.connections[node][neighbour]: _UpperCAmelCase = dist[node] + graph.connections[node][neighbour] priority_queue.update_key(_UpperCAmelCase , dist[neighbour] ) _UpperCAmelCase = node # running prim's algorithm while not priority_queue.is_empty(): _UpperCAmelCase = priority_queue.extract_min() for neighbour in graph.connections[node]: if dist[neighbour] > dist[node] + graph.connections[node][neighbour]: _UpperCAmelCase = dist[node] + graph.connections[node][neighbour] priority_queue.update_key(_UpperCAmelCase , dist[neighbour] ) _UpperCAmelCase = node return dist, parent
339
from typing import List import datasets from datasets.tasks import AudioClassification from ..folder_based_builder import folder_based_builder UpperCAmelCase__ = datasets.utils.logging.get_logger(__name__) class __lowerCAmelCase ( folder_based_builder.FolderBasedBuilderConfig ): UpperCamelCase = None UpperCamelCase = None class __lowerCAmelCase ( folder_based_builder.FolderBasedBuilder ): UpperCamelCase = datasets.Audio() UpperCamelCase = '''audio''' UpperCamelCase = AudioFolderConfig UpperCamelCase = 42 # definition at the bottom of the script UpperCamelCase = AudioClassification(audio_column='''audio''' , label_column='''label''' ) UpperCAmelCase__ = [ ".aiff", ".au", ".avr", ".caf", ".flac", ".htk", ".svx", ".mat4", ".mat5", ".mpc2k", ".ogg", ".paf", ".pvf", ".raw", ".rf64", ".sd2", ".sds", ".ircam", ".voc", ".w64", ".wav", ".nist", ".wavex", ".wve", ".xi", ".mp3", ".opus", ] UpperCAmelCase__ = AUDIO_EXTENSIONS
339
1
import unittest from transformers import ( MODEL_FOR_OBJECT_DETECTION_MAPPING, AutoFeatureExtractor, AutoModelForObjectDetection, ObjectDetectionPipeline, is_vision_available, pipeline, ) from transformers.testing_utils import ( is_pipeline_test, nested_simplify, require_pytesseract, require_tf, require_timm, require_torch, require_vision, slow, ) from .test_pipelines_common import ANY if is_vision_available(): from PIL import Image else: class __lowerCAmelCase : @staticmethod def _lowerCamelCase ( *A : Dict , **A : Any) -> List[Any]: """simple docstring""" pass @is_pipeline_test @require_vision @require_timm @require_torch class __lowerCAmelCase ( unittest.TestCase ): UpperCamelCase = MODEL_FOR_OBJECT_DETECTION_MAPPING def _lowerCamelCase ( self : Tuple , A : Any , A : Dict , A : Union[str, Any]) -> Optional[int]: """simple docstring""" _UpperCAmelCase = ObjectDetectionPipeline(model=A , image_processor=A) return object_detector, ["./tests/fixtures/tests_samples/COCO/000000039769.png"] def _lowerCamelCase ( self : Union[str, Any] , A : Optional[Any] , A : List[Any]) -> Tuple: """simple docstring""" _UpperCAmelCase = object_detector('./tests/fixtures/tests_samples/COCO/000000039769.png' , threshold=0.0) self.assertGreater(len(A) , 0) for detected_object in outputs: self.assertEqual( A , { 'score': ANY(A), 'label': ANY(A), 'box': {'xmin': ANY(A), 'ymin': ANY(A), 'xmax': ANY(A), 'ymax': ANY(A)}, } , ) import datasets _UpperCAmelCase = datasets.load_dataset('hf-internal-testing/fixtures_image_utils' , 'image' , split='test') _UpperCAmelCase = [ Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'), 'http://images.cocodataset.org/val2017/000000039769.jpg', # RGBA dataset[0]['file'], # LA dataset[1]['file'], # L dataset[2]['file'], ] _UpperCAmelCase = object_detector(A , threshold=0.0) self.assertEqual(len(A) , len(A)) for outputs in batch_outputs: self.assertGreater(len(A) , 0) for detected_object in outputs: self.assertEqual( A , { 'score': ANY(A), 'label': ANY(A), 'box': {'xmin': ANY(A), 'ymin': ANY(A), 'xmax': ANY(A), 'ymax': ANY(A)}, } , ) @require_tf @unittest.skip('Object detection not implemented in TF') def _lowerCamelCase ( self : Dict) -> Optional[int]: """simple docstring""" pass @require_torch def _lowerCamelCase ( self : Dict) -> str: """simple docstring""" _UpperCAmelCase = 'hf-internal-testing/tiny-detr-mobilenetsv3' _UpperCAmelCase = AutoModelForObjectDetection.from_pretrained(A) _UpperCAmelCase = AutoFeatureExtractor.from_pretrained(A) _UpperCAmelCase = ObjectDetectionPipeline(model=A , feature_extractor=A) _UpperCAmelCase = object_detector('http://images.cocodataset.org/val2017/000000039769.jpg' , threshold=0.0) self.assertEqual( nested_simplify(A , decimals=4) , [ {'score': 0.3_3_7_6, 'label': 'LABEL_0', 'box': {'xmin': 1_59, 'ymin': 1_20, 'xmax': 4_80, 'ymax': 3_59}}, {'score': 0.3_3_7_6, 'label': 'LABEL_0', 'box': {'xmin': 1_59, 'ymin': 1_20, 'xmax': 4_80, 'ymax': 3_59}}, ] , ) _UpperCAmelCase = object_detector( [ 'http://images.cocodataset.org/val2017/000000039769.jpg', 'http://images.cocodataset.org/val2017/000000039769.jpg', ] , threshold=0.0 , ) self.assertEqual( nested_simplify(A , decimals=4) , [ [ {'score': 0.3_3_7_6, 'label': 'LABEL_0', 'box': {'xmin': 1_59, 'ymin': 1_20, 'xmax': 4_80, 'ymax': 3_59}}, {'score': 0.3_3_7_6, 'label': 'LABEL_0', 'box': {'xmin': 1_59, 'ymin': 1_20, 'xmax': 4_80, 'ymax': 3_59}}, ], [ {'score': 0.3_3_7_6, 'label': 'LABEL_0', 'box': {'xmin': 1_59, 'ymin': 1_20, 'xmax': 4_80, 'ymax': 3_59}}, {'score': 0.3_3_7_6, 'label': 'LABEL_0', 'box': {'xmin': 1_59, 'ymin': 1_20, 'xmax': 4_80, 'ymax': 3_59}}, ], ] , ) @require_torch @slow def _lowerCamelCase ( self : Any) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = 'facebook/detr-resnet-50' _UpperCAmelCase = AutoModelForObjectDetection.from_pretrained(A) _UpperCAmelCase = AutoFeatureExtractor.from_pretrained(A) _UpperCAmelCase = ObjectDetectionPipeline(model=A , feature_extractor=A) _UpperCAmelCase = object_detector('http://images.cocodataset.org/val2017/000000039769.jpg') self.assertEqual( nested_simplify(A , decimals=4) , [ {'score': 0.9_9_8_2, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 70, 'xmax': 1_75, 'ymax': 1_17}}, {'score': 0.9_9_6_0, 'label': 'remote', 'box': {'xmin': 3_33, 'ymin': 72, 'xmax': 3_68, 'ymax': 1_87}}, {'score': 0.9_9_5_5, 'label': 'couch', 'box': {'xmin': 0, 'ymin': 1, 'xmax': 6_39, 'ymax': 4_73}}, {'score': 0.9_9_8_8, 'label': 'cat', 'box': {'xmin': 13, 'ymin': 52, 'xmax': 3_14, 'ymax': 4_70}}, {'score': 0.9_9_8_7, 'label': 'cat', 'box': {'xmin': 3_45, 'ymin': 23, 'xmax': 6_40, 'ymax': 3_68}}, ] , ) _UpperCAmelCase = object_detector( [ 'http://images.cocodataset.org/val2017/000000039769.jpg', 'http://images.cocodataset.org/val2017/000000039769.jpg', ]) self.assertEqual( nested_simplify(A , decimals=4) , [ [ {'score': 0.9_9_8_2, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 70, 'xmax': 1_75, 'ymax': 1_17}}, {'score': 0.9_9_6_0, 'label': 'remote', 'box': {'xmin': 3_33, 'ymin': 72, 'xmax': 3_68, 'ymax': 1_87}}, {'score': 0.9_9_5_5, 'label': 'couch', 'box': {'xmin': 0, 'ymin': 1, 'xmax': 6_39, 'ymax': 4_73}}, {'score': 0.9_9_8_8, 'label': 'cat', 'box': {'xmin': 13, 'ymin': 52, 'xmax': 3_14, 'ymax': 4_70}}, {'score': 0.9_9_8_7, 'label': 'cat', 'box': {'xmin': 3_45, 'ymin': 23, 'xmax': 6_40, 'ymax': 3_68}}, ], [ {'score': 0.9_9_8_2, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 70, 'xmax': 1_75, 'ymax': 1_17}}, {'score': 0.9_9_6_0, 'label': 'remote', 'box': {'xmin': 3_33, 'ymin': 72, 'xmax': 3_68, 'ymax': 1_87}}, {'score': 0.9_9_5_5, 'label': 'couch', 'box': {'xmin': 0, 'ymin': 1, 'xmax': 6_39, 'ymax': 4_73}}, {'score': 0.9_9_8_8, 'label': 'cat', 'box': {'xmin': 13, 'ymin': 52, 'xmax': 3_14, 'ymax': 4_70}}, {'score': 0.9_9_8_7, 'label': 'cat', 'box': {'xmin': 3_45, 'ymin': 23, 'xmax': 6_40, 'ymax': 3_68}}, ], ] , ) @require_torch @slow def _lowerCamelCase ( self : Any) -> List[Any]: """simple docstring""" _UpperCAmelCase = 'facebook/detr-resnet-50' _UpperCAmelCase = pipeline('object-detection' , model=A) _UpperCAmelCase = object_detector('http://images.cocodataset.org/val2017/000000039769.jpg') self.assertEqual( nested_simplify(A , decimals=4) , [ {'score': 0.9_9_8_2, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 70, 'xmax': 1_75, 'ymax': 1_17}}, {'score': 0.9_9_6_0, 'label': 'remote', 'box': {'xmin': 3_33, 'ymin': 72, 'xmax': 3_68, 'ymax': 1_87}}, {'score': 0.9_9_5_5, 'label': 'couch', 'box': {'xmin': 0, 'ymin': 1, 'xmax': 6_39, 'ymax': 4_73}}, {'score': 0.9_9_8_8, 'label': 'cat', 'box': {'xmin': 13, 'ymin': 52, 'xmax': 3_14, 'ymax': 4_70}}, {'score': 0.9_9_8_7, 'label': 'cat', 'box': {'xmin': 3_45, 'ymin': 23, 'xmax': 6_40, 'ymax': 3_68}}, ] , ) _UpperCAmelCase = object_detector( [ 'http://images.cocodataset.org/val2017/000000039769.jpg', 'http://images.cocodataset.org/val2017/000000039769.jpg', ]) self.assertEqual( nested_simplify(A , decimals=4) , [ [ {'score': 0.9_9_8_2, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 70, 'xmax': 1_75, 'ymax': 1_17}}, {'score': 0.9_9_6_0, 'label': 'remote', 'box': {'xmin': 3_33, 'ymin': 72, 'xmax': 3_68, 'ymax': 1_87}}, {'score': 0.9_9_5_5, 'label': 'couch', 'box': {'xmin': 0, 'ymin': 1, 'xmax': 6_39, 'ymax': 4_73}}, {'score': 0.9_9_8_8, 'label': 'cat', 'box': {'xmin': 13, 'ymin': 52, 'xmax': 3_14, 'ymax': 4_70}}, {'score': 0.9_9_8_7, 'label': 'cat', 'box': {'xmin': 3_45, 'ymin': 23, 'xmax': 6_40, 'ymax': 3_68}}, ], [ {'score': 0.9_9_8_2, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 70, 'xmax': 1_75, 'ymax': 1_17}}, {'score': 0.9_9_6_0, 'label': 'remote', 'box': {'xmin': 3_33, 'ymin': 72, 'xmax': 3_68, 'ymax': 1_87}}, {'score': 0.9_9_5_5, 'label': 'couch', 'box': {'xmin': 0, 'ymin': 1, 'xmax': 6_39, 'ymax': 4_73}}, {'score': 0.9_9_8_8, 'label': 'cat', 'box': {'xmin': 13, 'ymin': 52, 'xmax': 3_14, 'ymax': 4_70}}, {'score': 0.9_9_8_7, 'label': 'cat', 'box': {'xmin': 3_45, 'ymin': 23, 'xmax': 6_40, 'ymax': 3_68}}, ], ] , ) @require_torch @slow def _lowerCamelCase ( self : str) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = 0.9_9_8_5 _UpperCAmelCase = 'facebook/detr-resnet-50' _UpperCAmelCase = pipeline('object-detection' , model=A) _UpperCAmelCase = object_detector('http://images.cocodataset.org/val2017/000000039769.jpg' , threshold=A) self.assertEqual( nested_simplify(A , decimals=4) , [ {'score': 0.9_9_8_8, 'label': 'cat', 'box': {'xmin': 13, 'ymin': 52, 'xmax': 3_14, 'ymax': 4_70}}, {'score': 0.9_9_8_7, 'label': 'cat', 'box': {'xmin': 3_45, 'ymin': 23, 'xmax': 6_40, 'ymax': 3_68}}, ] , ) @require_torch @require_pytesseract @slow def _lowerCamelCase ( self : Dict) -> str: """simple docstring""" _UpperCAmelCase = 'Narsil/layoutlmv3-finetuned-funsd' _UpperCAmelCase = 0.9_9_9_3 _UpperCAmelCase = pipeline('object-detection' , model=A , threshold=A) _UpperCAmelCase = object_detector( 'https://huggingface.co/spaces/impira/docquery/resolve/2359223c1837a7587402bda0f2643382a6eefeab/invoice.png') self.assertEqual( nested_simplify(A , decimals=4) , [ {'score': 0.9_9_9_3, 'label': 'I-ANSWER', 'box': {'xmin': 2_94, 'ymin': 2_54, 'xmax': 3_43, 'ymax': 2_64}}, {'score': 0.9_9_9_3, 'label': 'I-ANSWER', 'box': {'xmin': 2_94, 'ymin': 2_54, 'xmax': 3_43, 'ymax': 2_64}}, ] , )
339
import sys from collections import defaultdict class __lowerCAmelCase : def __init__( self : int) -> str: """simple docstring""" _UpperCAmelCase = [] def _lowerCamelCase ( self : Any , A : List[str]) -> int: """simple docstring""" return self.node_position[vertex] def _lowerCamelCase ( self : Optional[Any] , A : Optional[int] , A : str) -> List[str]: """simple docstring""" _UpperCAmelCase = pos def _lowerCamelCase ( self : Tuple , A : Tuple , A : Dict , A : List[str] , A : Optional[Any]) -> Dict: """simple docstring""" if start > size // 2 - 1: return else: if 2 * start + 2 >= size: _UpperCAmelCase = 2 * start + 1 else: if heap[2 * start + 1] < heap[2 * start + 2]: _UpperCAmelCase = 2 * start + 1 else: _UpperCAmelCase = 2 * start + 2 if heap[smallest_child] < heap[start]: _UpperCAmelCase , _UpperCAmelCase = heap[smallest_child], positions[smallest_child] _UpperCAmelCase , _UpperCAmelCase = ( heap[start], positions[start], ) _UpperCAmelCase , _UpperCAmelCase = temp, tempa _UpperCAmelCase = self.get_position(positions[smallest_child]) self.set_position( positions[smallest_child] , self.get_position(positions[start])) self.set_position(positions[start] , A) self.top_to_bottom(A , A , A , A) def _lowerCamelCase ( self : Optional[int] , A : str , A : Optional[Any] , A : Optional[int] , A : str) -> Any: """simple docstring""" _UpperCAmelCase = position[index] while index != 0: _UpperCAmelCase = int((index - 2) / 2) if index % 2 == 0 else int((index - 1) / 2) if val < heap[parent]: _UpperCAmelCase = heap[parent] _UpperCAmelCase = position[parent] self.set_position(position[parent] , A) else: _UpperCAmelCase = val _UpperCAmelCase = temp self.set_position(A , A) break _UpperCAmelCase = parent else: _UpperCAmelCase = val _UpperCAmelCase = temp self.set_position(A , 0) def _lowerCamelCase ( self : Union[str, Any] , A : Optional[int] , A : Tuple) -> str: """simple docstring""" _UpperCAmelCase = len(A) // 2 - 1 for i in range(A , -1 , -1): self.top_to_bottom(A , A , len(A) , A) def _lowerCamelCase ( self : Optional[int] , A : int , A : str) -> List[str]: """simple docstring""" _UpperCAmelCase = positions[0] _UpperCAmelCase = sys.maxsize self.top_to_bottom(A , 0 , len(A) , A) return temp def A ( _UpperCAmelCase : int ) -> Any: '''simple docstring''' _UpperCAmelCase = Heap() _UpperCAmelCase = [0] * len(_UpperCAmelCase ) _UpperCAmelCase = [-1] * len(_UpperCAmelCase ) # Neighboring Tree Vertex of selected vertex # Minimum Distance of explored vertex with neighboring vertex of partial tree # formed in graph _UpperCAmelCase = [] # Heap of Distance of vertices from their neighboring vertex _UpperCAmelCase = [] for vertex in range(len(_UpperCAmelCase ) ): distance_tv.append(sys.maxsize ) positions.append(_UpperCAmelCase ) heap.node_position.append(_UpperCAmelCase ) _UpperCAmelCase = [] _UpperCAmelCase = 1 _UpperCAmelCase = sys.maxsize for neighbor, distance in adjacency_list[0]: _UpperCAmelCase = 0 _UpperCAmelCase = distance heap.heapify(_UpperCAmelCase , _UpperCAmelCase ) for _ in range(1 , len(_UpperCAmelCase ) ): _UpperCAmelCase = heap.delete_minimum(_UpperCAmelCase , _UpperCAmelCase ) if visited[vertex] == 0: tree_edges.append((nbr_tv[vertex], vertex) ) _UpperCAmelCase = 1 for neighbor, distance in adjacency_list[vertex]: if ( visited[neighbor] == 0 and distance < distance_tv[heap.get_position(_UpperCAmelCase )] ): _UpperCAmelCase = distance heap.bottom_to_top( _UpperCAmelCase , heap.get_position(_UpperCAmelCase ) , _UpperCAmelCase , _UpperCAmelCase ) _UpperCAmelCase = vertex return tree_edges if __name__ == "__main__": # pragma: no cover # < --------- Prims Algorithm --------- > UpperCAmelCase__ = int(input("Enter number of edges: ").strip()) UpperCAmelCase__ = defaultdict(list) for _ in range(edges_number): UpperCAmelCase__ = [int(x) for x in input().strip().split()] adjacency_list[edge[0]].append([edge[1], edge[2]]) adjacency_list[edge[1]].append([edge[0], edge[2]]) print(prisms_algorithm(adjacency_list))
339
1
import itertools import os import random import tempfile import unittest import numpy as np from transformers import TvltFeatureExtractor, is_datasets_available from transformers.testing_utils import check_json_file_has_correct_format, require_torch, require_torchaudio from transformers.utils.import_utils import is_torch_available from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin if is_torch_available(): import torch if is_datasets_available(): from datasets import load_dataset UpperCAmelCase__ = random.Random() def A ( _UpperCAmelCase : Optional[Any] , _UpperCAmelCase : Optional[int]=1.0 , _UpperCAmelCase : Tuple=None , _UpperCAmelCase : List[Any]=None ) -> Union[str, Any]: '''simple docstring''' if rng is None: _UpperCAmelCase = global_rng _UpperCAmelCase = [] for batch_idx in range(shape[0] ): values.append([] ) for _ in range(shape[1] ): values[-1].append(rng.random() * scale ) return values class __lowerCAmelCase ( unittest.TestCase ): def __init__( self : Optional[Any] , A : Dict , A : Union[str, Any]=7 , A : Union[str, Any]=4_00 , A : List[str]=20_00 , A : int=20_48 , A : Any=1_28 , A : List[str]=1 , A : Tuple=5_12 , A : List[str]=30 , A : List[Any]=4_41_00 , ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = min_seq_length _UpperCAmelCase = max_seq_length _UpperCAmelCase = (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1) _UpperCAmelCase = spectrogram_length _UpperCAmelCase = feature_size _UpperCAmelCase = num_audio_channels _UpperCAmelCase = hop_length _UpperCAmelCase = chunk_length _UpperCAmelCase = sampling_rate def _lowerCamelCase ( self : Union[str, Any]) -> int: """simple docstring""" return { "spectrogram_length": self.spectrogram_length, "feature_size": self.feature_size, "num_audio_channels": self.num_audio_channels, "hop_length": self.hop_length, "chunk_length": self.chunk_length, "sampling_rate": self.sampling_rate, } def _lowerCamelCase ( self : Tuple , A : Optional[Any]=False , A : Optional[int]=False) -> Union[str, Any]: """simple docstring""" def _flatten(A : Dict): return list(itertools.chain(*A)) if equal_length: _UpperCAmelCase = [floats_list((self.max_seq_length, self.feature_size)) for _ in range(self.batch_size)] else: # make sure that inputs increase in size _UpperCAmelCase = [ floats_list((x, self.feature_size)) for x in range(self.min_seq_length , self.max_seq_length , self.seq_length_diff) ] if numpify: _UpperCAmelCase = [np.asarray(A) for x in speech_inputs] return speech_inputs @require_torch @require_torchaudio class __lowerCAmelCase ( A , unittest.TestCase ): UpperCamelCase = TvltFeatureExtractor def _lowerCamelCase ( self : Any) -> List[Any]: """simple docstring""" _UpperCAmelCase = TvltFeatureExtractionTester(self) def _lowerCamelCase ( self : Any) -> Tuple: """simple docstring""" _UpperCAmelCase = self.feature_extraction_class(**self.feat_extract_dict) self.assertTrue(hasattr(A , 'spectrogram_length')) self.assertTrue(hasattr(A , 'feature_size')) self.assertTrue(hasattr(A , 'num_audio_channels')) self.assertTrue(hasattr(A , 'hop_length')) self.assertTrue(hasattr(A , 'chunk_length')) self.assertTrue(hasattr(A , 'sampling_rate')) def _lowerCamelCase ( self : Union[str, Any]) -> List[Any]: """simple docstring""" _UpperCAmelCase = self.feature_extraction_class(**self.feat_extract_dict) with tempfile.TemporaryDirectory() as tmpdirname: _UpperCAmelCase = feat_extract_first.save_pretrained(A)[0] check_json_file_has_correct_format(A) _UpperCAmelCase = self.feature_extraction_class.from_pretrained(A) _UpperCAmelCase = feat_extract_first.to_dict() _UpperCAmelCase = feat_extract_second.to_dict() _UpperCAmelCase = dict_first.pop('mel_filters') _UpperCAmelCase = dict_second.pop('mel_filters') self.assertTrue(np.allclose(A , A)) self.assertEqual(A , A) def _lowerCamelCase ( self : Union[str, Any]) -> Any: """simple docstring""" _UpperCAmelCase = self.feature_extraction_class(**self.feat_extract_dict) with tempfile.TemporaryDirectory() as tmpdirname: _UpperCAmelCase = os.path.join(A , 'feat_extract.json') feat_extract_first.to_json_file(A) _UpperCAmelCase = self.feature_extraction_class.from_json_file(A) _UpperCAmelCase = feat_extract_first.to_dict() _UpperCAmelCase = feat_extract_second.to_dict() _UpperCAmelCase = dict_first.pop('mel_filters') _UpperCAmelCase = dict_second.pop('mel_filters') self.assertTrue(np.allclose(A , A)) self.assertEqual(A , A) def _lowerCamelCase ( self : Optional[int]) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = self.feature_extraction_class(**self.feat_extract_dict) # create three inputs of length 800, 1000, and 1200 _UpperCAmelCase = [floats_list((1, x))[0] for x in range(8_00 , 14_00 , 2_00)] _UpperCAmelCase = [np.asarray(A) for speech_input in speech_inputs] # Test not batched input _UpperCAmelCase = feature_extractor(np_speech_inputs[0] , return_tensors='np' , sampling_rate=4_41_00).audio_values self.assertTrue(encoded_audios.ndim == 4) self.assertTrue(encoded_audios.shape[-1] == feature_extractor.feature_size) self.assertTrue(encoded_audios.shape[-2] <= feature_extractor.spectrogram_length) self.assertTrue(encoded_audios.shape[-3] == feature_extractor.num_channels) # Test batched _UpperCAmelCase = feature_extractor(A , return_tensors='np' , sampling_rate=4_41_00).audio_values self.assertTrue(encoded_audios.ndim == 4) self.assertTrue(encoded_audios.shape[-1] == feature_extractor.feature_size) self.assertTrue(encoded_audios.shape[-2] <= feature_extractor.spectrogram_length) self.assertTrue(encoded_audios.shape[-3] == feature_extractor.num_channels) # Test audio masking _UpperCAmelCase = feature_extractor( A , return_tensors='np' , sampling_rate=4_41_00 , mask_audio=A).audio_values self.assertTrue(encoded_audios.ndim == 4) self.assertTrue(encoded_audios.shape[-1] == feature_extractor.feature_size) self.assertTrue(encoded_audios.shape[-2] <= feature_extractor.spectrogram_length) self.assertTrue(encoded_audios.shape[-3] == feature_extractor.num_channels) # Test 2-D numpy arrays are batched. _UpperCAmelCase = [floats_list((1, x))[0] for x in (8_00, 8_00, 8_00)] _UpperCAmelCase = np.asarray(A) _UpperCAmelCase = feature_extractor(A , return_tensors='np' , sampling_rate=4_41_00).audio_values self.assertTrue(encoded_audios.ndim == 4) self.assertTrue(encoded_audios.shape[-1] == feature_extractor.feature_size) self.assertTrue(encoded_audios.shape[-2] <= feature_extractor.spectrogram_length) self.assertTrue(encoded_audios.shape[-3] == feature_extractor.num_channels) def _lowerCamelCase ( self : Dict , A : List[Any]) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = load_dataset('hf-internal-testing/librispeech_asr_dummy' , 'clean' , split='validation') # automatic decoding with librispeech _UpperCAmelCase = ds.sort('id').select(range(A))[:num_samples]['audio'] return [x["array"] for x in speech_samples] def _lowerCamelCase ( self : str) -> int: """simple docstring""" _UpperCAmelCase = self._load_datasamples(1) _UpperCAmelCase = TvltFeatureExtractor() _UpperCAmelCase = feature_extractor(A , return_tensors='pt').audio_values self.assertEquals(audio_values.shape , (1, 1, 1_92, 1_28)) _UpperCAmelCase = torch.tensor([[-0.3_0_3_2, -0.2_7_0_8], [-0.4_4_3_4, -0.4_0_0_7]]) self.assertTrue(torch.allclose(audio_values[0, 0, :2, :2] , A , atol=1E-4))
339
import torch from transformers import CamembertForMaskedLM, CamembertTokenizer def A ( _UpperCAmelCase : str , _UpperCAmelCase : Any , _UpperCAmelCase : List[str] , _UpperCAmelCase : Optional[int]=5 ) -> List[Any]: '''simple docstring''' # Adapted from https://github.com/pytorch/fairseq/blob/master/fairseq/models/roberta/hub_interface.py assert masked_input.count('<mask>' ) == 1 _UpperCAmelCase = torch.tensor(tokenizer.encode(_UpperCAmelCase , add_special_tokens=_UpperCAmelCase ) ).unsqueeze(0 ) # Batch size 1 _UpperCAmelCase = model(_UpperCAmelCase )[0] # The last hidden-state is the first element of the output tuple _UpperCAmelCase = (input_ids.squeeze() == tokenizer.mask_token_id).nonzero().item() _UpperCAmelCase = logits[0, masked_index, :] _UpperCAmelCase = logits.softmax(dim=0 ) _UpperCAmelCase , _UpperCAmelCase = prob.topk(k=_UpperCAmelCase , dim=0 ) _UpperCAmelCase = ' '.join( [tokenizer.convert_ids_to_tokens(indices[i].item() ) for i in range(len(_UpperCAmelCase ) )] ) _UpperCAmelCase = tokenizer.mask_token _UpperCAmelCase = [] for index, predicted_token_bpe in enumerate(topk_predicted_token_bpe.split(' ' ) ): _UpperCAmelCase = predicted_token_bpe.replace('\u2581' , ' ' ) if " {0}".format(_UpperCAmelCase ) in masked_input: topk_filled_outputs.append( ( masked_input.replace(' {0}'.format(_UpperCAmelCase ) , _UpperCAmelCase ), values[index].item(), predicted_token, ) ) else: topk_filled_outputs.append( ( masked_input.replace(_UpperCAmelCase , _UpperCAmelCase ), values[index].item(), predicted_token, ) ) return topk_filled_outputs UpperCAmelCase__ = CamembertTokenizer.from_pretrained("camembert-base") UpperCAmelCase__ = CamembertForMaskedLM.from_pretrained("camembert-base") model.eval() UpperCAmelCase__ = "Le camembert est <mask> :)" print(fill_mask(masked_input, model, tokenizer, topk=3))
339
1
import gc import random import unittest import numpy as np import torch from PIL import Image from diffusers import ( DDIMScheduler, KandinskyVaaInpaintPipeline, 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 ( A , unittest.TestCase ): UpperCamelCase = KandinskyVaaInpaintPipeline UpperCamelCase = ['''image_embeds''', '''negative_image_embeds''', '''image''', '''mask_image'''] UpperCamelCase = [ '''image_embeds''', '''negative_image_embeds''', '''image''', '''mask_image''', ] UpperCamelCase = [ '''generator''', '''height''', '''width''', '''latents''', '''guidance_scale''', '''num_inference_steps''', '''return_dict''', '''guidance_scale''', '''num_images_per_prompt''', '''output_type''', '''return_dict''', ] UpperCamelCase = False @property def _lowerCamelCase ( self : Optional[int]) -> Dict: """simple docstring""" return 32 @property def _lowerCamelCase ( self : Dict) -> Tuple: """simple docstring""" return 32 @property def _lowerCamelCase ( self : Optional[int]) -> Optional[Any]: """simple docstring""" return self.time_input_dim @property def _lowerCamelCase ( self : Any) -> Tuple: """simple docstring""" return self.time_input_dim * 4 @property def _lowerCamelCase ( self : List[Any]) -> str: """simple docstring""" return 1_00 @property def _lowerCamelCase ( self : Any) -> List[Any]: """simple docstring""" torch.manual_seed(0) _UpperCAmelCase = { 'in_channels': 9, # 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, } _UpperCAmelCase = UNetaDConditionModel(**A) return model @property def _lowerCamelCase ( self : Dict) -> List[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 _lowerCamelCase ( self : Any) -> Optional[int]: """simple docstring""" torch.manual_seed(0) _UpperCAmelCase = VQModel(**self.dummy_movq_kwargs) return model def _lowerCamelCase ( self : str) -> int: """simple docstring""" _UpperCAmelCase = self.dummy_unet _UpperCAmelCase = self.dummy_movq _UpperCAmelCase = DDIMScheduler( num_train_timesteps=10_00 , beta_schedule='linear' , beta_start=0.0_0_0_8_5 , beta_end=0.0_1_2 , clip_sample=A , set_alpha_to_one=A , steps_offset=1 , prediction_type='epsilon' , thresholding=A , ) _UpperCAmelCase = { 'unet': unet, 'scheduler': scheduler, 'movq': movq, } return components def _lowerCamelCase ( self : Dict , A : str , A : Union[str, Any]=0) -> int: """simple docstring""" _UpperCAmelCase = floats_tensor((1, self.text_embedder_hidden_size) , rng=random.Random(A)).to(A) _UpperCAmelCase = floats_tensor((1, self.text_embedder_hidden_size) , rng=random.Random(seed + 1)).to( A) # create init_image _UpperCAmelCase = floats_tensor((1, 3, 64, 64) , rng=random.Random(A)).to(A) _UpperCAmelCase = image.cpu().permute(0 , 2 , 3 , 1)[0] _UpperCAmelCase = Image.fromarray(np.uinta(A)).convert('RGB').resize((2_56, 2_56)) # create mask _UpperCAmelCase = np.ones((64, 64) , dtype=np.floataa) _UpperCAmelCase = 0 if str(A).startswith('mps'): _UpperCAmelCase = torch.manual_seed(A) else: _UpperCAmelCase = torch.Generator(device=A).manual_seed(A) _UpperCAmelCase = { 'image': init_image, 'mask_image': mask, 'image_embeds': image_embeds, 'negative_image_embeds': negative_image_embeds, 'generator': generator, 'height': 64, 'width': 64, 'num_inference_steps': 2, 'guidance_scale': 4.0, 'output_type': 'np', } return inputs def _lowerCamelCase ( self : int) -> Any: """simple docstring""" _UpperCAmelCase = 'cpu' _UpperCAmelCase = self.get_dummy_components() _UpperCAmelCase = self.pipeline_class(**A) _UpperCAmelCase = pipe.to(A) pipe.set_progress_bar_config(disable=A) _UpperCAmelCase = pipe(**self.get_dummy_inputs(A)) _UpperCAmelCase = output.images _UpperCAmelCase = pipe( **self.get_dummy_inputs(A) , return_dict=A , )[0] _UpperCAmelCase = image[0, -3:, -3:, -1] _UpperCAmelCase = image_from_tuple[0, -3:, -3:, -1] print(F"image.shape {image.shape}") assert image.shape == (1, 64, 64, 3) _UpperCAmelCase = np.array( [0.5_0_7_7_5_9_0_3, 0.4_9_5_2_7_1_9_5, 0.4_8_8_2_4_5_4_3, 0.5_0_1_9_2_2_3_7, 0.4_8_6_4_4_9_0_6, 0.4_9_3_7_3_8_1_4, 0.4_7_8_0_5_9_8, 0.4_7_2_3_4_8_2_7, 0.4_8_3_2_7_8_4_8]) 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()}" def _lowerCamelCase ( self : List[Any]) -> Tuple: """simple docstring""" super().test_inference_batch_single_identical(expected_max_diff=3E-3) @slow @require_torch_gpu class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Union[str, Any]) -> Tuple: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def _lowerCamelCase ( self : Dict) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/kandinskyv22/kandinskyv22_inpaint_cat_with_hat_fp16.npy') _UpperCAmelCase = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/kandinsky/cat.png') _UpperCAmelCase = np.ones((7_68, 7_68) , dtype=np.floataa) _UpperCAmelCase = 0 _UpperCAmelCase = 'a hat' _UpperCAmelCase = KandinskyVaaPriorPipeline.from_pretrained( 'kandinsky-community/kandinsky-2-2-prior' , torch_dtype=torch.floataa) pipe_prior.to(A) _UpperCAmelCase = KandinskyVaaInpaintPipeline.from_pretrained( 'kandinsky-community/kandinsky-2-2-decoder-inpaint' , torch_dtype=torch.floataa) _UpperCAmelCase = pipeline.to(A) pipeline.set_progress_bar_config(disable=A) _UpperCAmelCase = torch.Generator(device='cpu').manual_seed(0) _UpperCAmelCase , _UpperCAmelCase = pipe_prior( A , generator=A , num_inference_steps=5 , negative_prompt='' , ).to_tuple() _UpperCAmelCase = pipeline( image=A , mask_image=A , image_embeds=A , negative_image_embeds=A , generator=A , num_inference_steps=1_00 , height=7_68 , width=7_68 , output_type='np' , ) _UpperCAmelCase = output.images[0] assert image.shape == (7_68, 7_68, 3) assert_mean_pixel_difference(A , A)
339
import math import unittest def A ( _UpperCAmelCase : int ) -> bool: '''simple docstring''' assert isinstance(_UpperCAmelCase , _UpperCAmelCase ) and ( number >= 0 ), "'number' must been an int and positive" if 1 < number < 4: # 2 and 3 are primes return True elif number < 2 or number % 2 == 0 or number % 3 == 0: # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes return False # All primes number are in format of 6k +/- 1 for i in range(5 , int(math.sqrt(_UpperCAmelCase ) + 1 ) , 6 ): if number % i == 0 or number % (i + 2) == 0: return False return True class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Tuple) -> Union[str, Any]: """simple docstring""" self.assertTrue(is_prime(2)) self.assertTrue(is_prime(3)) self.assertTrue(is_prime(5)) self.assertTrue(is_prime(7)) self.assertTrue(is_prime(11)) self.assertTrue(is_prime(13)) self.assertTrue(is_prime(17)) self.assertTrue(is_prime(19)) self.assertTrue(is_prime(23)) self.assertTrue(is_prime(29)) def _lowerCamelCase ( self : Optional[int]) -> Any: """simple docstring""" with self.assertRaises(A): is_prime(-19) self.assertFalse( is_prime(0) , 'Zero doesn\'t have any positive factors, primes must have exactly two.' , ) self.assertFalse( is_prime(1) , 'One only has 1 positive factor, primes must have exactly two.' , ) self.assertFalse(is_prime(2 * 2)) self.assertFalse(is_prime(2 * 3)) self.assertFalse(is_prime(3 * 3)) self.assertFalse(is_prime(3 * 5)) self.assertFalse(is_prime(3 * 5 * 7)) if __name__ == "__main__": unittest.main()
339
1
def A ( _UpperCAmelCase : int , _UpperCAmelCase : int ) -> str: '''simple docstring''' if a < 0 or b < 0: raise ValueError('the value of both inputs must be positive' ) _UpperCAmelCase = str(bin(_UpperCAmelCase ) )[2:] # remove the leading "0b" _UpperCAmelCase = str(bin(_UpperCAmelCase ) )[2:] # remove the leading "0b" _UpperCAmelCase = max(len(_UpperCAmelCase ) , len(_UpperCAmelCase ) ) return "0b" + "".join( str(int(char_a == '1' and char_b == '1' ) ) for char_a, char_b in zip(a_binary.zfill(_UpperCAmelCase ) , b_binary.zfill(_UpperCAmelCase ) ) ) if __name__ == "__main__": import doctest doctest.testmod()
339
from typing import Dict, List from nltk.translate import gleu_score import datasets from datasets import MetricInfo UpperCAmelCase__ = "\\n@misc{wu2016googles,\n title={Google's Neural Machine Translation System: Bridging the Gap between Human and Machine Translation},\n author={Yonghui Wu and Mike Schuster and Zhifeng Chen and Quoc V. Le and Mohammad Norouzi and Wolfgang Macherey\n and Maxim Krikun and Yuan Cao and Qin Gao and Klaus Macherey and Jeff Klingner and Apurva Shah and Melvin\n Johnson and Xiaobing Liu and Łukasz Kaiser and Stephan Gouws and Yoshikiyo Kato and Taku Kudo and Hideto\n Kazawa and Keith Stevens and George Kurian and Nishant Patil and Wei Wang and Cliff Young and\n Jason Smith and Jason Riesa and Alex Rudnick and Oriol Vinyals and Greg Corrado and Macduff Hughes\n and Jeffrey Dean},\n year={2016},\n eprint={1609.08144},\n archivePrefix={arXiv},\n primaryClass={cs.CL}\n}\n" UpperCAmelCase__ = "\\nThe BLEU score has some undesirable properties when used for single\nsentences, as it was designed to be a corpus measure. We therefore\nuse a slightly different score for our RL experiments which we call\nthe 'GLEU score'. For the GLEU score, we record all sub-sequences of\n1, 2, 3 or 4 tokens in output and target sequence (n-grams). We then\ncompute a recall, which is the ratio of the number of matching n-grams\nto the number of total n-grams in the target (ground truth) sequence,\nand a precision, which is the ratio of the number of matching n-grams\nto the number of total n-grams in the generated output sequence. Then\nGLEU score is simply the minimum of recall and precision. This GLEU\nscore's range is always between 0 (no matches) and 1 (all match) and\nit is symmetrical when switching output and target. According to\nour experiments, GLEU score correlates quite well with the BLEU\nmetric on a corpus level but does not have its drawbacks for our per\nsentence reward objective.\n" UpperCAmelCase__ = "\\nComputes corpus-level Google BLEU (GLEU) score of translated segments against one or more references.\nInstead of averaging the sentence level GLEU scores (i.e. macro-average precision), Wu et al. (2016) sum up the matching\ntokens and the max of hypothesis and reference tokens for each sentence, then compute using the aggregate values.\n\nArgs:\n predictions (list of str): list of translations to score.\n Each translation should be tokenized into a list of tokens.\n references (list of list of str): list of lists of references for each translation.\n Each reference should be tokenized into a list of tokens.\n min_len (int): The minimum order of n-gram this function should extract. Defaults to 1.\n max_len (int): The maximum order of n-gram this function should extract. Defaults to 4.\n\nReturns:\n 'google_bleu': google_bleu score\n\nExamples:\n Example 1:\n >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'always',\n ... 'disobeys', 'the', 'commands', 'of', 'the', 'cat']\n >>> ref1a = ['It', 'is', 'the', 'guiding', 'principle', 'which',\n ... 'guarantees', 'the', 'rubber', 'duck', 'forces', 'never',\n ... 'being', 'under', 'the', 'command', 'of', 'the', 'cat']\n\n >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was',\n ... 'interested', 'in', 'world', 'history']\n >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history',\n ... 'because', 'he', 'read', 'the', 'book']\n\n >>> list_of_references = [[ref1a], [ref2a]]\n >>> hypotheses = [hyp1, hyp2]\n >>> google_bleu = datasets.load_metric(\"google_bleu\")\n >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references)\n >>> print(round(results[\"google_bleu\"], 2))\n 0.44\n\n Example 2:\n >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'always',\n ... 'disobeys', 'the', 'commands', 'of', 'the', 'cat']\n >>> ref1a = ['It', 'is', 'the', 'guiding', 'principle', 'which',\n ... 'guarantees', 'the', 'rubber', 'duck', 'forces', 'never',\n ... 'being', 'under', 'the', 'command', 'of', 'the', 'cat']\n >>> ref1b = ['It', 'is', 'a', 'guide', 'to', 'action', 'that',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'will', 'never',\n ... 'heed', 'the', 'cat', 'commands']\n >>> ref1c = ['It', 'is', 'the', 'practical', 'guide', 'for', 'the',\n ... 'rubber', 'duck', 'army', 'never', 'to', 'heed', 'the', 'directions',\n ... 'of', 'the', 'cat']\n\n >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was',\n ... 'interested', 'in', 'world', 'history']\n >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history',\n ... 'because', 'he', 'read', 'the', 'book']\n\n >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]\n >>> hypotheses = [hyp1, hyp2]\n >>> google_bleu = datasets.load_metric(\"google_bleu\")\n >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references)\n >>> print(round(results[\"google_bleu\"], 2))\n 0.61\n\n Example 3:\n >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'always',\n ... 'disobeys', 'the', 'commands', 'of', 'the', 'cat']\n >>> ref1a = ['It', 'is', 'the', 'guiding', 'principle', 'which',\n ... 'guarantees', 'the', 'rubber', 'duck', 'forces', 'never',\n ... 'being', 'under', 'the', 'command', 'of', 'the', 'cat']\n >>> ref1b = ['It', 'is', 'a', 'guide', 'to', 'action', 'that',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'will', 'never',\n ... 'heed', 'the', 'cat', 'commands']\n >>> ref1c = ['It', 'is', 'the', 'practical', 'guide', 'for', 'the',\n ... 'rubber', 'duck', 'army', 'never', 'to', 'heed', 'the', 'directions',\n ... 'of', 'the', 'cat']\n\n >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was',\n ... 'interested', 'in', 'world', 'history']\n >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history',\n ... 'because', 'he', 'read', 'the', 'book']\n\n >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]\n >>> hypotheses = [hyp1, hyp2]\n >>> google_bleu = datasets.load_metric(\"google_bleu\")\n >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references, min_len=2)\n >>> print(round(results[\"google_bleu\"], 2))\n 0.53\n\n Example 4:\n >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'always',\n ... 'disobeys', 'the', 'commands', 'of', 'the', 'cat']\n >>> ref1a = ['It', 'is', 'the', 'guiding', 'principle', 'which',\n ... 'guarantees', 'the', 'rubber', 'duck', 'forces', 'never',\n ... 'being', 'under', 'the', 'command', 'of', 'the', 'cat']\n >>> ref1b = ['It', 'is', 'a', 'guide', 'to', 'action', 'that',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'will', 'never',\n ... 'heed', 'the', 'cat', 'commands']\n >>> ref1c = ['It', 'is', 'the', 'practical', 'guide', 'for', 'the',\n ... 'rubber', 'duck', 'army', 'never', 'to', 'heed', 'the', 'directions',\n ... 'of', 'the', 'cat']\n\n >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was',\n ... 'interested', 'in', 'world', 'history']\n >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history',\n ... 'because', 'he', 'read', 'the', 'book']\n\n >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]\n >>> hypotheses = [hyp1, hyp2]\n >>> google_bleu = datasets.load_metric(\"google_bleu\")\n >>> results = google_bleu.compute(predictions=hypotheses,references=list_of_references, min_len=2, max_len=6)\n >>> print(round(results[\"google_bleu\"], 2))\n 0.4\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class __lowerCAmelCase ( datasets.Metric ): def _lowerCamelCase ( self : str) -> MetricInfo: """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': datasets.Sequence(datasets.Value('string' , id='token') , id='sequence'), 'references': datasets.Sequence( datasets.Sequence(datasets.Value('string' , id='token') , id='sequence') , id='references'), }) , ) def _lowerCamelCase ( self : Union[str, Any] , A : List[List[List[str]]] , A : List[List[str]] , A : int = 1 , A : int = 4 , ) -> Dict[str, float]: """simple docstring""" return { "google_bleu": gleu_score.corpus_gleu( list_of_references=A , hypotheses=A , min_len=A , max_len=A) }
339
1
import gc import unittest import numpy as np import torch from diffusers import StableDiffusionKDiffusionPipeline from diffusers.utils import slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu enable_full_determinism() @slow @require_torch_gpu class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Tuple) -> List[Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def _lowerCamelCase ( self : str) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = StableDiffusionKDiffusionPipeline.from_pretrained('CompVis/stable-diffusion-v1-4') _UpperCAmelCase = sd_pipe.to(A) sd_pipe.set_progress_bar_config(disable=A) sd_pipe.set_scheduler('sample_euler') _UpperCAmelCase = 'A painting of a squirrel eating a burger' _UpperCAmelCase = torch.manual_seed(0) _UpperCAmelCase = sd_pipe([prompt] , generator=A , guidance_scale=9.0 , num_inference_steps=20 , output_type='np') _UpperCAmelCase = output.images _UpperCAmelCase = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _UpperCAmelCase = np.array([0.0_4_4_7, 0.0_4_9_2, 0.0_4_6_8, 0.0_4_0_8, 0.0_3_8_3, 0.0_4_0_8, 0.0_3_5_4, 0.0_3_8_0, 0.0_3_3_9]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2 def _lowerCamelCase ( self : Union[str, Any]) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = StableDiffusionKDiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base') _UpperCAmelCase = sd_pipe.to(A) sd_pipe.set_progress_bar_config(disable=A) sd_pipe.set_scheduler('sample_euler') _UpperCAmelCase = 'A painting of a squirrel eating a burger' _UpperCAmelCase = torch.manual_seed(0) _UpperCAmelCase = sd_pipe([prompt] , generator=A , guidance_scale=9.0 , num_inference_steps=20 , output_type='np') _UpperCAmelCase = output.images _UpperCAmelCase = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _UpperCAmelCase = np.array([0.1_2_3_7, 0.1_3_2_0, 0.1_4_3_8, 0.1_3_5_9, 0.1_3_9_0, 0.1_1_3_2, 0.1_2_7_7, 0.1_1_7_5, 0.1_1_1_2]) assert np.abs(image_slice.flatten() - expected_slice).max() < 5E-1 def _lowerCamelCase ( self : int) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = StableDiffusionKDiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base') _UpperCAmelCase = sd_pipe.to(A) sd_pipe.set_progress_bar_config(disable=A) sd_pipe.set_scheduler('sample_dpmpp_2m') _UpperCAmelCase = 'A painting of a squirrel eating a burger' _UpperCAmelCase = torch.manual_seed(0) _UpperCAmelCase = sd_pipe( [prompt] , generator=A , guidance_scale=7.5 , num_inference_steps=15 , output_type='np' , use_karras_sigmas=A , ) _UpperCAmelCase = output.images _UpperCAmelCase = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _UpperCAmelCase = np.array( [0.1_1_3_8_1_6_8_9, 0.1_2_1_1_2_9_2_1, 0.1_3_8_9_4_5_7, 0.1_2_5_4_9_6_0_6, 0.1_2_4_4_9_6_4, 0.1_0_8_3_1_5_1_7, 0.1_1_5_6_2_8_6_6, 0.1_0_8_6_7_8_1_6, 0.1_0_4_9_9_0_4_8]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2
339
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_sentencepiece_available, is_tf_available, is_tokenizers_available, is_torch_available, ) if is_sentencepiece_available(): from ..ta.tokenization_ta import TaTokenizer else: from ...utils.dummy_sentencepiece_objects import TaTokenizer UpperCAmelCase__ = TaTokenizer if is_tokenizers_available(): from ..ta.tokenization_ta_fast import TaTokenizerFast else: from ...utils.dummy_tokenizers_objects import TaTokenizerFast UpperCAmelCase__ = TaTokenizerFast UpperCAmelCase__ = {"configuration_mt5": ["MT5Config", "MT5OnnxConfig"]} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase__ = [ "MT5EncoderModel", "MT5ForConditionalGeneration", "MT5ForQuestionAnswering", "MT5Model", "MT5PreTrainedModel", "MT5Stack", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase__ = ["TFMT5EncoderModel", "TFMT5ForConditionalGeneration", "TFMT5Model"] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase__ = ["FlaxMT5EncoderModel", "FlaxMT5ForConditionalGeneration", "FlaxMT5Model"] if TYPE_CHECKING: from .configuration_mta import MTaConfig, MTaOnnxConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_mta import ( MTaEncoderModel, MTaForConditionalGeneration, MTaForQuestionAnswering, MTaModel, MTaPreTrainedModel, MTaStack, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_mta import TFMTaEncoderModel, TFMTaForConditionalGeneration, TFMTaModel try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_mta import FlaxMTaEncoderModel, FlaxMTaForConditionalGeneration, FlaxMTaModel else: import sys UpperCAmelCase__ = _LazyModule( __name__, globals()["__file__"], _import_structure, extra_objects={"MT5Tokenizer": MTaTokenizer, "MT5TokenizerFast": MTaTokenizerFast}, module_spec=__spec__, )
339
1
from ..utils import DummyObject, requires_backends class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : List[str] , *A : Dict , **A : Optional[int]) -> Optional[int]: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : Tuple , *A : str , **A : Optional[int]) -> str: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : List[Any] , *A : Optional[Any] , **A : Tuple) -> Optional[int]: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : Optional[Any] , *A : List[str] , **A : Tuple) -> Optional[Any]: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : Tuple , *A : Optional[int] , **A : Tuple) -> List[Any]: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : Union[str, Any] , *A : Optional[Any] , **A : List[Any]) -> List[str]: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : Any , *A : int , **A : Any) -> Union[str, Any]: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : Tuple , *A : Optional[Any] , **A : Union[str, Any]) -> Tuple: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : Union[str, Any] , *A : Any , **A : List[str]) -> Any: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : Optional[int] , *A : List[Any] , **A : Optional[Any]) -> Optional[int]: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : List[str] , *A : Optional[Any] , **A : List[Any]) -> str: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : List[str] , *A : List[Any] , **A : str) -> Tuple: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : Any , *A : Dict , **A : Union[str, Any]) -> Dict: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : Tuple , *A : List[str] , **A : Dict) -> Optional[int]: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : Any , *A : Optional[Any] , **A : List[Any]) -> Optional[Any]: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : Union[str, Any] , *A : Union[str, Any] , **A : Tuple) -> Any: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : List[Any] , *A : Optional[int] , **A : str) -> Union[str, Any]: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : List[str] , *A : List[Any] , **A : List[Any]) -> List[Any]: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : Union[str, Any] , *A : List[Any] , **A : Union[str, Any]) -> Union[str, Any]: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : List[str] , *A : Tuple , **A : Union[str, Any]) -> int: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : int , *A : str , **A : Tuple) -> Optional[Any]: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : int , *A : List[str] , **A : Any) -> str: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : Dict , *A : Any , **A : int) -> Optional[Any]: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : str , *A : List[str] , **A : int) -> str: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : str , *A : Dict , **A : Dict) -> List[str]: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : Any , *A : str , **A : int) -> int: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : str , *A : Optional[int] , **A : Dict) -> str: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : Optional[int] , *A : Optional[int] , **A : int) -> Any: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : List[Any] , *A : List[str] , **A : Dict) -> Union[str, Any]: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : List[str] , *A : str , **A : Optional[Any]) -> List[Any]: """simple docstring""" requires_backends(self , ['sentencepiece']) class __lowerCAmelCase ( metaclass=A ): UpperCamelCase = ['''sentencepiece'''] def __init__( self : int , *A : Tuple , **A : Optional[Any]) -> Union[str, Any]: """simple docstring""" requires_backends(self , ['sentencepiece'])
339
from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCAmelCase__ = logging.get_logger(__name__) UpperCAmelCase__ = { "s-JoL/Open-Llama-V1": "https://huggingface.co/s-JoL/Open-Llama-V1/blob/main/config.json", } class __lowerCAmelCase ( A ): UpperCamelCase = '''open-llama''' def __init__( self : str , A : List[Any]=10_00_00 , A : Tuple=40_96 , A : Tuple=1_10_08 , A : List[str]=32 , A : Tuple=32 , A : Optional[Any]="silu" , A : int=20_48 , A : Optional[Any]=0.0_2 , A : Dict=1E-6 , A : Optional[Any]=True , A : List[Any]=0 , A : Dict=1 , A : int=2 , A : Dict=False , A : Optional[int]=True , A : List[Any]=0.1 , A : str=0.1 , A : Dict=True , A : Optional[Any]=True , A : Dict=None , **A : Union[str, Any] , ) -> Dict: """simple docstring""" _UpperCAmelCase = vocab_size _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = hidden_size _UpperCAmelCase = intermediate_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = hidden_act _UpperCAmelCase = initializer_range _UpperCAmelCase = rms_norm_eps _UpperCAmelCase = use_cache _UpperCAmelCase = kwargs.pop( 'use_memorry_efficient_attention' , A) _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_dropout_prob _UpperCAmelCase = use_stable_embedding _UpperCAmelCase = shared_input_output_embedding _UpperCAmelCase = rope_scaling self._rope_scaling_validation() super().__init__( pad_token_id=A , bos_token_id=A , eos_token_id=A , tie_word_embeddings=A , **A , ) def _lowerCamelCase ( self : List[str]) -> Union[str, Any]: """simple docstring""" if self.rope_scaling is None: return if not isinstance(self.rope_scaling , A) or len(self.rope_scaling) != 2: raise ValueError( '`rope_scaling` must be a dictionary with with two fields, `name` and `factor`, ' F"got {self.rope_scaling}") _UpperCAmelCase = self.rope_scaling.get('type' , A) _UpperCAmelCase = self.rope_scaling.get('factor' , A) if rope_scaling_type is None or rope_scaling_type not in ["linear", "dynamic"]: raise ValueError( F"`rope_scaling`'s name field must be one of ['linear', 'dynamic'], got {rope_scaling_type}") if rope_scaling_factor is None or not isinstance(A , A) or rope_scaling_factor <= 1.0: raise ValueError(F"`rope_scaling`'s factor field must be an float > 1, got {rope_scaling_factor}")
339
1
import logging import os import random import sys from dataclasses import dataclass, field from typing import Optional import datasets import numpy as np import pandas as pd from datasets import load_dataset import transformers from transformers import ( AutoConfig, BartForSequenceClassification, DataCollatorWithPadding, EvalPrediction, HfArgumentParser, TapexTokenizer, Trainer, TrainingArguments, default_data_collator, set_seed, ) from transformers.trainer_utils import get_last_checkpoint from transformers.utils import check_min_version from transformers.utils.versions import require_version # Will error if the minimal version of Transformers is not installed. Remove at your own risks. check_min_version("4.17.0.dev0") require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/text-classification/requirements.txt") UpperCAmelCase__ = logging.getLogger(__name__) @dataclass class __lowerCAmelCase : UpperCamelCase = field( default='''tab_fact''' , metadata={'''help''': '''The name of the dataset to use (via the datasets library).'''} ) UpperCamelCase = field( default='''tab_fact''' , metadata={'''help''': '''The configuration name of the dataset to use (via the datasets library).'''} , ) UpperCamelCase = field( default=1_0_2_4 , metadata={ '''help''': ( '''The maximum total input sequence length after tokenization. Sequences longer ''' '''than this will be truncated, sequences shorter will be padded.''' ) } , ) UpperCamelCase = field( default=A , metadata={'''help''': '''Overwrite the cached preprocessed datasets or not.'''} ) UpperCamelCase = field( default=A , 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.''' ) } , ) UpperCamelCase = field( default=A , metadata={ '''help''': ( '''For debugging purposes or quicker training, truncate the number of training examples to this ''' '''value if set.''' ) } , ) UpperCamelCase = field( default=A , metadata={ '''help''': ( '''For debugging purposes or quicker training, truncate the number of evaluation examples to this ''' '''value if set.''' ) } , ) UpperCamelCase = field( default=A , metadata={ '''help''': ( '''For debugging purposes or quicker training, truncate the number of prediction examples to this ''' '''value if set.''' ) } , ) UpperCamelCase = field( default=A , metadata={'''help''': '''A csv or a json file containing the training data.'''} ) UpperCamelCase = field( default=A , metadata={'''help''': '''A csv or a json file containing the validation data.'''} ) UpperCamelCase = field(default=A , metadata={'''help''': '''A csv or a json file containing the test data.'''} ) def _lowerCamelCase ( self : str) -> List[Any]: """simple docstring""" if self.dataset_name is not None: pass elif self.train_file is None or self.validation_file is None: raise ValueError('Need either a GLUE task, a training/validation file or a dataset name.') else: _UpperCAmelCase = self.train_file.split('.')[-1] assert train_extension in ["csv", "json"], "`train_file` should be a csv or a json file." _UpperCAmelCase = self.validation_file.split('.')[-1] assert ( validation_extension == train_extension ), "`validation_file` should have the same extension (csv or json) as `train_file`." @dataclass class __lowerCAmelCase : UpperCamelCase = field( default=A , metadata={'''help''': '''Path to pretrained model or model identifier from huggingface.co/models'''} ) UpperCamelCase = field( default=A , metadata={'''help''': '''Pretrained config name or path if not the same as model_name'''} ) UpperCamelCase = field( default=A , metadata={'''help''': '''Pretrained tokenizer name or path if not the same as model_name'''} ) UpperCamelCase = field( default=A , metadata={'''help''': '''Where do you want to store the pretrained models downloaded from huggingface.co'''} , ) UpperCamelCase = field( default=A , metadata={'''help''': '''Whether to use one of the fast tokenizer (backed by the tokenizers library) or not.'''} , ) UpperCamelCase = field( default='''main''' , metadata={'''help''': '''The specific model version to use (can be a branch name, tag name or commit id).'''} , ) UpperCamelCase = field( default=A , metadata={ '''help''': ( '''Will use the token generated when running `huggingface-cli login` (necessary to use this script ''' '''with private models).''' ) } , ) def A ( ) -> Optional[int]: '''simple docstring''' # See all possible arguments in src/transformers/training_args.py # or by passing the --help flag to this script. # We now keep distinct sets of args, for a cleaner separation of concerns. _UpperCAmelCase = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments) ) if len(sys.argv ) == 2 and sys.argv[1].endswith('.json' ): # If we pass only one argument to the script and it's the path to a json file, # let's parse it to get our arguments. _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1] ) ) else: _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = parser.parse_args_into_dataclasses() # Setup logging logging.basicConfig( format='%(asctime)s - %(levelname)s - %(name)s - %(message)s' , datefmt='%m/%d/%Y %H:%M:%S' , handlers=[logging.StreamHandler(sys.stdout )] , ) _UpperCAmelCase = training_args.get_process_log_level() logger.setLevel(_UpperCAmelCase ) datasets.utils.logging.set_verbosity(_UpperCAmelCase ) transformers.utils.logging.set_verbosity(_UpperCAmelCase ) transformers.utils.logging.enable_default_handler() transformers.utils.logging.enable_explicit_format() # Log on each process the small summary: logger.warning( F"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}" + F"distributed training: {bool(training_args.local_rank != -1 )}, 16-bits training: {training_args.fpaa}" ) logger.info(F"Training/evaluation parameters {training_args}" ) # Detecting last checkpoint. _UpperCAmelCase = None if os.path.isdir(training_args.output_dir ) and training_args.do_train and not training_args.overwrite_output_dir: _UpperCAmelCase = get_last_checkpoint(training_args.output_dir ) if last_checkpoint is None and len(os.listdir(training_args.output_dir ) ) > 0: raise ValueError( F"Output directory ({training_args.output_dir}) already exists and is not empty. " 'Use --overwrite_output_dir to overcome.' ) elif last_checkpoint is not None and training_args.resume_from_checkpoint is None: logger.info( F"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change " 'the `--output_dir` or add `--overwrite_output_dir` to train from scratch.' ) # Set seed before initializing model. set_seed(training_args.seed ) # Get the datasets: you can either provide your own CSV/JSON training and evaluation files (see below) # or specify a GLUE benchmark task (the dataset will be downloaded automatically from the datasets Hub). # # For JSON files, this script will use the `question` column for the input question and `table` column for the corresponding table. # # If the CSVs/JSONs contain only one non-label column, the script does single sentence classification on this # single column. You can easily tweak this behavior (see below) # # In distributed training, the load_dataset function guarantee that only one local process can concurrently # download the dataset. if data_args.dataset_name is not None: # Downloading and loading a dataset from the hub. _UpperCAmelCase = load_dataset( data_args.dataset_name , data_args.dataset_config_name , cache_dir=model_args.cache_dir ) else: # Loading a dataset from your local files. # CSV/JSON training and evaluation files are needed. _UpperCAmelCase = {'train': data_args.train_file, 'validation': data_args.validation_file} # Get the test dataset: you can provide your own CSV/JSON test file (see below) # when you use `do_predict` without specifying a GLUE benchmark task. if training_args.do_predict: if data_args.test_file is not None: _UpperCAmelCase = data_args.train_file.split('.' )[-1] _UpperCAmelCase = data_args.test_file.split('.' )[-1] assert ( test_extension == train_extension ), "`test_file` should have the same extension (csv or json) as `train_file`." _UpperCAmelCase = data_args.test_file else: raise ValueError('Need either a GLUE task or a test file for `do_predict`.' ) for key in data_files.keys(): logger.info(F"load a local file for {key}: {data_files[key]}" ) if data_args.train_file.endswith('.csv' ): # Loading a dataset from local csv files _UpperCAmelCase = load_dataset('csv' , data_files=_UpperCAmelCase , cache_dir=model_args.cache_dir ) else: # Loading a dataset from local json files _UpperCAmelCase = load_dataset('json' , data_files=_UpperCAmelCase , cache_dir=model_args.cache_dir ) # See more about loading any type of standard or custom dataset at # https://huggingface.co/docs/datasets/loading_datasets.html. # Labels _UpperCAmelCase = raw_datasets['train'].features['label'].names _UpperCAmelCase = len(_UpperCAmelCase ) # Load pretrained model and tokenizer # # In distributed training, the .from_pretrained methods guarantee that only one local process can concurrently # download model & vocab. _UpperCAmelCase = AutoConfig.from_pretrained( model_args.config_name if model_args.config_name else model_args.model_name_or_path , num_labels=_UpperCAmelCase , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , ) # load tapex tokenizer _UpperCAmelCase = TapexTokenizer.from_pretrained( model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path , cache_dir=model_args.cache_dir , use_fast=model_args.use_fast_tokenizer , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , add_prefix_space=_UpperCAmelCase , ) _UpperCAmelCase = BartForSequenceClassification.from_pretrained( model_args.model_name_or_path , from_tf=bool('.ckpt' in model_args.model_name_or_path ) , config=_UpperCAmelCase , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , ) # Padding strategy if data_args.pad_to_max_length: _UpperCAmelCase = 'max_length' else: # We will pad later, dynamically at batch creation, to the max sequence length in each batch _UpperCAmelCase = False # Some models have set the order of the labels to use, so let's make sure we do use it. _UpperCAmelCase = {'Refused': 0, 'Entailed': 1} _UpperCAmelCase = {0: 'Refused', 1: 'Entailed'} if data_args.max_seq_length > tokenizer.model_max_length: logger.warning( F"The max_seq_length passed ({data_args.max_seq_length}) is larger than the maximum length for the" F"model ({tokenizer.model_max_length}). Using max_seq_length={tokenizer.model_max_length}." ) _UpperCAmelCase = min(data_args.max_seq_length , tokenizer.model_max_length ) def preprocess_tabfact_function(_UpperCAmelCase : Union[str, Any] ): # Tokenize the texts def _convert_table_text_to_pandas(_UpperCAmelCase : Dict ): _UpperCAmelCase = [_table_row.split('#' ) for _table_row in _table_text.strip('\n' ).split('\n' )] _UpperCAmelCase = pd.DataFrame.from_records(_table_content[1:] , columns=_table_content[0] ) return _table_pd _UpperCAmelCase = examples['statement'] _UpperCAmelCase = list(map(_convert_table_text_to_pandas , examples['table_text'] ) ) _UpperCAmelCase = tokenizer(_UpperCAmelCase , _UpperCAmelCase , padding=_UpperCAmelCase , max_length=_UpperCAmelCase , truncation=_UpperCAmelCase ) _UpperCAmelCase = examples['label'] return result with training_args.main_process_first(desc='dataset map pre-processing' ): _UpperCAmelCase = raw_datasets.map( _UpperCAmelCase , batched=_UpperCAmelCase , load_from_cache_file=not data_args.overwrite_cache , desc='Running tokenizer on dataset' , ) if training_args.do_train: if "train" not in raw_datasets: raise ValueError('--do_train requires a train dataset' ) _UpperCAmelCase = raw_datasets['train'] if data_args.max_train_samples is not None: _UpperCAmelCase = train_dataset.select(range(data_args.max_train_samples ) ) if training_args.do_eval: if "validation" not in raw_datasets and "validation_matched" not in raw_datasets: raise ValueError('--do_eval requires a validation dataset' ) _UpperCAmelCase = raw_datasets['validation'] if data_args.max_eval_samples is not None: _UpperCAmelCase = eval_dataset.select(range(data_args.max_eval_samples ) ) if training_args.do_predict or data_args.test_file is not None: if "test" not in raw_datasets and "test_matched" not in raw_datasets: raise ValueError('--do_predict requires a test dataset' ) _UpperCAmelCase = raw_datasets['test'] if data_args.max_predict_samples is not None: _UpperCAmelCase = predict_dataset.select(range(data_args.max_predict_samples ) ) # Log a few random samples from the training set: if training_args.do_train: for index in random.sample(range(len(_UpperCAmelCase ) ) , 3 ): logger.info(F"Sample {index} of the training set: {train_dataset[index]}." ) # You can define your custom compute_metrics function. It takes an `EvalPrediction` object (a namedtuple with a # predictions and label_ids field) and has to return a dictionary string to float. def compute_metrics(_UpperCAmelCase : EvalPrediction ): _UpperCAmelCase = p.predictions[0] if isinstance(p.predictions , _UpperCAmelCase ) else p.predictions _UpperCAmelCase = np.argmax(_UpperCAmelCase , axis=1 ) return {"accuracy": (preds == p.label_ids).astype(np.floataa ).mean().item()} # Data collator will default to DataCollatorWithPadding, so we change it if we already did the padding. if data_args.pad_to_max_length: _UpperCAmelCase = default_data_collator elif training_args.fpaa: _UpperCAmelCase = DataCollatorWithPadding(_UpperCAmelCase , pad_to_multiple_of=8 ) else: _UpperCAmelCase = None # Initialize our Trainer _UpperCAmelCase = Trainer( model=_UpperCAmelCase , args=_UpperCAmelCase , train_dataset=train_dataset if training_args.do_train else None , eval_dataset=eval_dataset if training_args.do_eval else None , compute_metrics=_UpperCAmelCase , tokenizer=_UpperCAmelCase , data_collator=_UpperCAmelCase , ) # Training if training_args.do_train: _UpperCAmelCase = None if training_args.resume_from_checkpoint is not None: _UpperCAmelCase = training_args.resume_from_checkpoint elif last_checkpoint is not None: _UpperCAmelCase = last_checkpoint _UpperCAmelCase = trainer.train(resume_from_checkpoint=_UpperCAmelCase ) _UpperCAmelCase = train_result.metrics _UpperCAmelCase = ( data_args.max_train_samples if data_args.max_train_samples is not None else len(_UpperCAmelCase ) ) _UpperCAmelCase = min(_UpperCAmelCase , len(_UpperCAmelCase ) ) trainer.save_model() # Saves the tokenizer too for easy upload trainer.log_metrics('train' , _UpperCAmelCase ) trainer.save_metrics('train' , _UpperCAmelCase ) trainer.save_state() # Evaluation if training_args.do_eval: logger.info('*** Evaluate ***' ) _UpperCAmelCase = trainer.evaluate(eval_dataset=_UpperCAmelCase ) _UpperCAmelCase = data_args.max_eval_samples if data_args.max_eval_samples is not None else len(_UpperCAmelCase ) _UpperCAmelCase = min(_UpperCAmelCase , len(_UpperCAmelCase ) ) trainer.log_metrics('eval' , _UpperCAmelCase ) trainer.save_metrics('eval' , _UpperCAmelCase ) if training_args.do_predict: logger.info('*** Predict ***' ) # Removing the `label` columns because it contains -1 and Trainer won't like that. _UpperCAmelCase = predict_dataset.remove_columns('label' ) _UpperCAmelCase = trainer.predict(_UpperCAmelCase , metric_key_prefix='predict' ).predictions _UpperCAmelCase = np.argmax(_UpperCAmelCase , axis=1 ) _UpperCAmelCase = os.path.join(training_args.output_dir , 'predict_results_tabfact.txt' ) if trainer.is_world_process_zero(): with open(_UpperCAmelCase , 'w' ) as writer: logger.info('***** Predict Results *****' ) writer.write('index\tprediction\n' ) for index, item in enumerate(_UpperCAmelCase ): _UpperCAmelCase = label_list[item] writer.write(F"{index}\t{item}\n" ) _UpperCAmelCase = {'finetuned_from': model_args.model_name_or_path, 'tasks': 'text-classification'} if training_args.push_to_hub: trainer.push_to_hub(**_UpperCAmelCase ) else: trainer.create_model_card(**_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[Any] ) -> Optional[Any]: '''simple docstring''' # For xla_spawn (TPUs) main() if __name__ == "__main__": main()
339
def A ( _UpperCAmelCase : str ) -> bool: '''simple docstring''' return credit_card_number.startswith(('34', '35', '37', '4', '5', '6') ) def A ( _UpperCAmelCase : str ) -> bool: '''simple docstring''' _UpperCAmelCase = credit_card_number _UpperCAmelCase = 0 _UpperCAmelCase = len(_UpperCAmelCase ) - 2 for i in range(_UpperCAmelCase , -1 , -2 ): # double the value of every second digit _UpperCAmelCase = int(cc_number[i] ) digit *= 2 # If doubling of a number results in a two digit number # i.e greater than 9(e.g., 6 × 2 = 12), # then add the digits of the product (e.g., 12: 1 + 2 = 3, 15: 1 + 5 = 6), # to get a single digit number. if digit > 9: digit %= 10 digit += 1 _UpperCAmelCase = cc_number[:i] + str(_UpperCAmelCase ) + cc_number[i + 1 :] total += digit # Sum up the remaining digits for i in range(len(_UpperCAmelCase ) - 1 , -1 , -2 ): total += int(cc_number[i] ) return total % 10 == 0 def A ( _UpperCAmelCase : str ) -> bool: '''simple docstring''' _UpperCAmelCase = F"{credit_card_number} is an invalid credit card number because" if not credit_card_number.isdigit(): print(F"{error_message} it has nonnumerical characters." ) return False if not 13 <= len(_UpperCAmelCase ) <= 16: print(F"{error_message} of its length." ) return False if not validate_initial_digits(_UpperCAmelCase ): print(F"{error_message} of its first two digits." ) return False if not luhn_validation(_UpperCAmelCase ): print(F"{error_message} it fails the Luhn check." ) return False print(F"{credit_card_number} is a valid credit card number." ) return True if __name__ == "__main__": import doctest doctest.testmod() validate_credit_card_number("4111111111111111") validate_credit_card_number("32323")
339
1
import argparse import json import os import fairseq import torch from fairseq.data import Dictionary from transformers import ( WavaVecaConfig, WavaVecaCTCTokenizer, WavaVecaFeatureExtractor, WavaVecaForCTC, WavaVecaForPreTraining, WavaVecaProcessor, logging, ) from transformers.models.wavaveca.modeling_wavaveca import WavaVecaForSequenceClassification logging.set_verbosity_info() 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", "adapter_layer": "encoder.layers.*.adapter_layer", "w2v_model.layer_norm": "feature_projection.layer_norm", "quantizer.weight_proj": "quantizer.weight_proj", "quantizer.vars": "quantizer.codevectors", "project_q": "project_q", "final_proj": "project_hid", "w2v_encoder.proj": "lm_head", "mask_emb": "masked_spec_embed", "pooling_layer.linear": "projector", "pooling_layer.projection": "classifier", } UpperCAmelCase__ = [ "lm_head", "quantizer.weight_proj", "quantizer.codevectors", "project_q", "project_hid", "projector", "classifier", ] def A ( _UpperCAmelCase : List[str] ) -> Dict: '''simple docstring''' _UpperCAmelCase = {} with open(_UpperCAmelCase , 'r' ) as file: for line_number, line in enumerate(_UpperCAmelCase ): _UpperCAmelCase = line.strip() if line: _UpperCAmelCase = line.split() _UpperCAmelCase = line_number _UpperCAmelCase = words[0] _UpperCAmelCase = value return result def A ( _UpperCAmelCase : Optional[int] , _UpperCAmelCase : Any , _UpperCAmelCase : List[str] , _UpperCAmelCase : int , _UpperCAmelCase : Optional[int] ) -> int: '''simple docstring''' for attribute in key.split('.' ): _UpperCAmelCase = getattr(_UpperCAmelCase , _UpperCAmelCase ) _UpperCAmelCase = None for param_key in PARAM_MAPPING.keys(): if full_name.endswith(_UpperCAmelCase ): _UpperCAmelCase = PARAM_MAPPING[full_name.split('.' )[-1]] _UpperCAmelCase = 'param' if weight_type is not None and weight_type != "param": _UpperCAmelCase = getattr(_UpperCAmelCase , _UpperCAmelCase ).shape elif weight_type is not None and weight_type == "param": _UpperCAmelCase = hf_pointer for attribute in hf_param_name.split('.' ): _UpperCAmelCase = getattr(_UpperCAmelCase , _UpperCAmelCase ) _UpperCAmelCase = shape_pointer.shape # let's reduce dimension _UpperCAmelCase = value[0] else: _UpperCAmelCase = 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": _UpperCAmelCase = value elif weight_type == "weight_g": _UpperCAmelCase = value elif weight_type == "weight_v": _UpperCAmelCase = value elif weight_type == "bias": _UpperCAmelCase = value elif weight_type == "param": for attribute in hf_param_name.split('.' ): _UpperCAmelCase = getattr(_UpperCAmelCase , _UpperCAmelCase ) _UpperCAmelCase = value else: _UpperCAmelCase = value logger.info(F"{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}." ) def A ( _UpperCAmelCase : Union[str, Any] , _UpperCAmelCase : Optional[Any] , _UpperCAmelCase : int , _UpperCAmelCase : Optional[Any] , _UpperCAmelCase : List[str] ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = None for param_key in PARAM_MAPPING.keys(): if full_name.endswith(_UpperCAmelCase ): _UpperCAmelCase = PARAM_MAPPING[full_name.split('.' )[-1]] _UpperCAmelCase = 'param' if weight_type is not None and weight_type != "param": _UpperCAmelCase = '.'.join([key, weight_type] ) elif weight_type is not None and weight_type == "param": _UpperCAmelCase = '.'.join([key, hf_param_name] ) else: _UpperCAmelCase = key _UpperCAmelCase = value if 'lm_head' in full_key else value[0] UpperCAmelCase__ = { "W_a": "linear_1.weight", "W_b": "linear_2.weight", "b_a": "linear_1.bias", "b_b": "linear_2.bias", "ln_W": "norm.weight", "ln_b": "norm.bias", } def A ( _UpperCAmelCase : List[Any] , _UpperCAmelCase : Any , _UpperCAmelCase : List[str]=None , _UpperCAmelCase : Dict=None ) -> List[str]: '''simple docstring''' _UpperCAmelCase = False for key, mapped_key in MAPPING.items(): _UpperCAmelCase = 'wav2vec2.' + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key if key in name or key.split('w2v_model.' )[-1] == name.split('.' )[0]: _UpperCAmelCase = True if "*" in mapped_key: _UpperCAmelCase = name.split(_UpperCAmelCase )[0].split('.' )[-2] _UpperCAmelCase = mapped_key.replace('*' , _UpperCAmelCase ) if "weight_g" in name: _UpperCAmelCase = 'weight_g' elif "weight_v" in name: _UpperCAmelCase = 'weight_v' elif "bias" in name: _UpperCAmelCase = 'bias' elif "weight" in name: # TODO: don't match quantizer.weight_proj _UpperCAmelCase = 'weight' else: _UpperCAmelCase = None if hf_dict is not None: rename_dict(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) else: set_recursively(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) return is_used return is_used def A ( _UpperCAmelCase : List[Any] , _UpperCAmelCase : str , _UpperCAmelCase : Dict ) -> List[str]: '''simple docstring''' _UpperCAmelCase = [] _UpperCAmelCase = fairseq_model.state_dict() _UpperCAmelCase = hf_model.wavaveca.feature_extractor for name, value in fairseq_dict.items(): _UpperCAmelCase = False if "conv_layers" in name: load_conv_layer( _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , hf_model.config.feat_extract_norm == 'group' , ) _UpperCAmelCase = True else: _UpperCAmelCase = load_wavaveca_layer(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) if not is_used: unused_weights.append(_UpperCAmelCase ) logger.warning(F"Unused weights: {unused_weights}" ) def A ( _UpperCAmelCase : Union[str, Any] , _UpperCAmelCase : Optional[int] , _UpperCAmelCase : Union[str, Any] , _UpperCAmelCase : Union[str, Any] , _UpperCAmelCase : Optional[Any] ) -> List[Any]: '''simple docstring''' _UpperCAmelCase = full_name.split('conv_layers.' )[-1] _UpperCAmelCase = name.split('.' ) _UpperCAmelCase = int(items[0] ) _UpperCAmelCase = int(items[1] ) if type_id == 0: if "bias" in name: 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." ) _UpperCAmelCase = 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." ) _UpperCAmelCase = value logger.info(F"Feat extract conv layer {layer_id} was initialized from {full_name}." ) elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm): if "bias" in name: if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape: raise ValueError( F"{full_name} has size {value.shape}, but" F" {feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape} was found." ) _UpperCAmelCase = value logger.info(F"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}." ) elif "weight" in name: if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape: raise ValueError( F"{full_name} has size {value.shape}, but" F" {feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape} was found." ) _UpperCAmelCase = value logger.info(F"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}." ) else: unused_weights.append(_UpperCAmelCase ) @torch.no_grad() def A ( _UpperCAmelCase : List[Any] , _UpperCAmelCase : str , _UpperCAmelCase : Optional[Any]=None , _UpperCAmelCase : Optional[Any]=None , _UpperCAmelCase : Optional[int]=True , _UpperCAmelCase : Tuple=False ) -> Dict: '''simple docstring''' if config_path is not None: _UpperCAmelCase = WavaVecaConfig.from_pretrained(_UpperCAmelCase ) else: _UpperCAmelCase = WavaVecaConfig() if is_seq_class: _UpperCAmelCase = read_txt_into_dict(_UpperCAmelCase ) _UpperCAmelCase = idalabel _UpperCAmelCase = WavaVecaForSequenceClassification(_UpperCAmelCase ) _UpperCAmelCase = WavaVecaFeatureExtractor( feature_size=1 , sampling_rate=16_000 , padding_value=0 , do_normalize=_UpperCAmelCase , return_attention_mask=_UpperCAmelCase , ) feature_extractor.save_pretrained(_UpperCAmelCase ) elif is_finetuned: if dict_path: _UpperCAmelCase = Dictionary.load(_UpperCAmelCase ) # important change bos & pad token id since CTC symbol is <pad> and # not <s> as in fairseq _UpperCAmelCase = target_dict.pad_index _UpperCAmelCase = target_dict.bos_index _UpperCAmelCase = target_dict.eos_index _UpperCAmelCase = len(target_dict.symbols ) _UpperCAmelCase = os.path.join(_UpperCAmelCase , 'vocab.json' ) if not os.path.isdir(_UpperCAmelCase ): logger.error('--pytorch_dump_folder_path ({}) should be a directory'.format(_UpperCAmelCase ) ) return os.makedirs(_UpperCAmelCase , exist_ok=_UpperCAmelCase ) _UpperCAmelCase = target_dict.indices # fairseq has the <pad> and <s> switched _UpperCAmelCase = 0 _UpperCAmelCase = 1 with open(_UpperCAmelCase , 'w' , encoding='utf-8' ) as vocab_handle: json.dump(_UpperCAmelCase , _UpperCAmelCase ) _UpperCAmelCase = WavaVecaCTCTokenizer( _UpperCAmelCase , 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=_UpperCAmelCase , ) _UpperCAmelCase = True if config.feat_extract_norm == 'layer' else False _UpperCAmelCase = WavaVecaFeatureExtractor( feature_size=1 , sampling_rate=16_000 , padding_value=0 , do_normalize=_UpperCAmelCase , return_attention_mask=_UpperCAmelCase , ) _UpperCAmelCase = WavaVecaProcessor(feature_extractor=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) processor.save_pretrained(_UpperCAmelCase ) _UpperCAmelCase = WavaVecaForCTC(_UpperCAmelCase ) else: _UpperCAmelCase = WavaVecaForPreTraining(_UpperCAmelCase ) if is_finetuned or is_seq_class: _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = fairseq.checkpoint_utils.load_model_ensemble_and_task( [checkpoint_path] , arg_overrides={'data': '/'.join(dict_path.split('/' )[:-1] )} ) else: _UpperCAmelCase = argparse.Namespace(task='audio_pretraining' ) _UpperCAmelCase = fairseq.tasks.setup_task(_UpperCAmelCase ) _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path] , task=_UpperCAmelCase ) _UpperCAmelCase = model[0].eval() recursively_load_weights(_UpperCAmelCase , _UpperCAmelCase , not is_finetuned ) hf_wavavec.save_pretrained(_UpperCAmelCase ) 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_path", default=None, type=str, help="Path to hf config.json of model to convert") parser.add_argument( "--not_finetuned", action="store_true", help="Whether the model to convert is a fine-tuned model or not" ) parser.add_argument( "--is_seq_class", action="store_true", help="Whether the model to convert is a fine-tuned sequence classification model or not", ) UpperCAmelCase__ = parser.parse_args() UpperCAmelCase__ = not args.not_finetuned and not args.is_seq_class convert_wavaveca_checkpoint( args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, is_finetuned, args.is_seq_class, )
339
from functools import reduce UpperCAmelCase__ = ( "73167176531330624919225119674426574742355349194934" "96983520312774506326239578318016984801869478851843" "85861560789112949495459501737958331952853208805511" "12540698747158523863050715693290963295227443043557" "66896648950445244523161731856403098711121722383113" "62229893423380308135336276614282806444486645238749" "30358907296290491560440772390713810515859307960866" "70172427121883998797908792274921901699720888093776" "65727333001053367881220235421809751254540594752243" "52584907711670556013604839586446706324415722155397" "53697817977846174064955149290862569321978468622482" "83972241375657056057490261407972968652414535100474" "82166370484403199890008895243450658541227588666881" "16427171479924442928230863465674813919123162824586" "17866458359124566529476545682848912883142607690042" "24219022671055626321111109370544217506941658960408" "07198403850962455444362981230987879927244284909188" "84580156166097919133875499200524063689912560717606" "05886116467109405077541002256983155200055935729725" "71636269561882670428252483600823257530420752963450" ) def A ( _UpperCAmelCase : str = N ) -> int: '''simple docstring''' return max( # mypy cannot properly interpret reduce int(reduce(lambda _UpperCAmelCase , _UpperCAmelCase : str(int(_UpperCAmelCase ) * int(_UpperCAmelCase ) ) , n[i : i + 13] ) ) for i in range(len(_UpperCAmelCase ) - 12 ) ) if __name__ == "__main__": print(f"""{solution() = }""")
339
1
import unittest import numpy as np import torch from diffusers import ScoreSdeVePipeline, ScoreSdeVeScheduler, UNetaDModel from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device enable_full_determinism() class __lowerCAmelCase ( unittest.TestCase ): @property def _lowerCamelCase ( self : List[Any]) -> Dict: """simple docstring""" torch.manual_seed(0) _UpperCAmelCase = UNetaDModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=3 , out_channels=3 , down_block_types=('DownBlock2D', 'AttnDownBlock2D') , up_block_types=('AttnUpBlock2D', 'UpBlock2D') , ) return model def _lowerCamelCase ( self : Optional[Any]) -> List[str]: """simple docstring""" _UpperCAmelCase = self.dummy_uncond_unet _UpperCAmelCase = ScoreSdeVeScheduler() _UpperCAmelCase = ScoreSdeVePipeline(unet=A , scheduler=A) sde_ve.to(A) sde_ve.set_progress_bar_config(disable=A) _UpperCAmelCase = torch.manual_seed(0) _UpperCAmelCase = sde_ve(num_inference_steps=2 , output_type='numpy' , generator=A).images _UpperCAmelCase = torch.manual_seed(0) _UpperCAmelCase = sde_ve(num_inference_steps=2 , output_type='numpy' , generator=A , return_dict=A)[ 0 ] _UpperCAmelCase = image[0, -3:, -3:, -1] _UpperCAmelCase = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 32, 32, 3) _UpperCAmelCase = np.array([0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2 assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1E-2 @slow @require_torch class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Union[str, Any]) -> Any: """simple docstring""" _UpperCAmelCase = 'google/ncsnpp-church-256' _UpperCAmelCase = UNetaDModel.from_pretrained(A) _UpperCAmelCase = ScoreSdeVeScheduler.from_pretrained(A) _UpperCAmelCase = ScoreSdeVePipeline(unet=A , scheduler=A) sde_ve.to(A) sde_ve.set_progress_bar_config(disable=A) _UpperCAmelCase = torch.manual_seed(0) _UpperCAmelCase = sde_ve(num_inference_steps=10 , output_type='numpy' , generator=A).images _UpperCAmelCase = image[0, -3:, -3:, -1] assert image.shape == (1, 2_56, 2_56, 3) _UpperCAmelCase = np.array([0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2
339
from __future__ import annotations from collections.abc import Callable UpperCAmelCase__ = list[list[float | int]] def A ( _UpperCAmelCase : Matrix , _UpperCAmelCase : Matrix ) -> Matrix: '''simple docstring''' _UpperCAmelCase = len(_UpperCAmelCase ) _UpperCAmelCase = [[0 for _ in range(size + 1 )] for _ in range(_UpperCAmelCase )] _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 for row in range(_UpperCAmelCase ): for col in range(_UpperCAmelCase ): _UpperCAmelCase = matrix[row][col] _UpperCAmelCase = vector[row][0] _UpperCAmelCase = 0 _UpperCAmelCase = 0 while row < size and col < size: # pivoting _UpperCAmelCase = max((abs(augmented[rowa][col] ), rowa) for rowa in range(_UpperCAmelCase , _UpperCAmelCase ) )[ 1 ] if augmented[pivot_row][col] == 0: col += 1 continue else: _UpperCAmelCase , _UpperCAmelCase = augmented[pivot_row], augmented[row] for rowa in range(row + 1 , _UpperCAmelCase ): _UpperCAmelCase = augmented[rowa][col] / augmented[row][col] _UpperCAmelCase = 0 for cola in range(col + 1 , size + 1 ): augmented[rowa][cola] -= augmented[row][cola] * ratio row += 1 col += 1 # back substitution for col in range(1 , _UpperCAmelCase ): for row in range(_UpperCAmelCase ): _UpperCAmelCase = augmented[row][col] / augmented[col][col] for cola in range(_UpperCAmelCase , size + 1 ): augmented[row][cola] -= augmented[col][cola] * ratio # round to get rid of numbers like 2.000000000000004 return [ [round(augmented[row][size] / augmented[row][row] , 10 )] for row in range(_UpperCAmelCase ) ] def A ( _UpperCAmelCase : list[int] ) -> Callable[[int], int]: '''simple docstring''' _UpperCAmelCase = len(_UpperCAmelCase ) _UpperCAmelCase = [[0 for _ in range(_UpperCAmelCase )] for _ in range(_UpperCAmelCase )] _UpperCAmelCase = [[0] for _ in range(_UpperCAmelCase )] _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 for x_val, y_val in enumerate(_UpperCAmelCase ): for col in range(_UpperCAmelCase ): _UpperCAmelCase = (x_val + 1) ** (size - col - 1) _UpperCAmelCase = y_val _UpperCAmelCase = solve(_UpperCAmelCase , _UpperCAmelCase ) def interpolated_func(_UpperCAmelCase : int ) -> int: return sum( round(coeffs[x_val][0] ) * (var ** (size - x_val - 1)) for x_val in range(_UpperCAmelCase ) ) return interpolated_func def A ( _UpperCAmelCase : int ) -> int: '''simple docstring''' return ( 1 - variable + variable**2 - variable**3 + variable**4 - variable**5 + variable**6 - variable**7 + variable**8 - variable**9 + variable**10 ) def A ( _UpperCAmelCase : Callable[[int], int] = question_function , _UpperCAmelCase : int = 10 ) -> int: '''simple docstring''' _UpperCAmelCase = [func(_UpperCAmelCase ) for x_val in range(1 , order + 1 )] _UpperCAmelCase = [ interpolate(data_points[:max_coeff] ) for max_coeff in range(1 , order + 1 ) ] _UpperCAmelCase = 0 _UpperCAmelCase = 42 _UpperCAmelCase = 42 for poly in polynomials: _UpperCAmelCase = 1 while func(_UpperCAmelCase ) == poly(_UpperCAmelCase ): x_val += 1 ret += poly(_UpperCAmelCase ) return ret if __name__ == "__main__": print(f"""{solution() = }""")
339
1
# coding=utf-8 # Copyright 2023 The HuggingFace Inc. team. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # this script dumps information about the environment import os import platform import sys UpperCAmelCase__ = "3" print("Python version:", sys.version) print("OS platform:", platform.platform()) print("OS architecture:", platform.machine()) try: import torch print("Torch version:", torch.__version__) print("Cuda available:", torch.cuda.is_available()) print("Cuda version:", torch.version.cuda) print("CuDNN version:", torch.backends.cudnn.version()) print("Number of GPUs available:", torch.cuda.device_count()) except ImportError: print("Torch version:", None) try: import transformers print("transformers version:", transformers.__version__) except ImportError: print("transformers version:", None)
339
from __future__ import annotations def A ( _UpperCAmelCase : list[int] ) -> bool: '''simple docstring''' return len(set(_UpperCAmelCase ) ) == len(_UpperCAmelCase ) if __name__ == "__main__": import doctest doctest.testmod()
339
1
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available UpperCAmelCase__ = { "configuration_graphormer": ["GRAPHORMER_PRETRAINED_CONFIG_ARCHIVE_MAP", "GraphormerConfig"], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase__ = [ "GRAPHORMER_PRETRAINED_MODEL_ARCHIVE_LIST", "GraphormerForGraphClassification", "GraphormerModel", "GraphormerPreTrainedModel", ] if TYPE_CHECKING: from .configuration_graphormer import GRAPHORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, GraphormerConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_graphormer import ( GRAPHORMER_PRETRAINED_MODEL_ARCHIVE_LIST, GraphormerForGraphClassification, GraphormerModel, GraphormerPreTrainedModel, ) else: import sys UpperCAmelCase__ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
339
import os UpperCAmelCase__ = {"I": 1, "V": 5, "X": 10, "L": 50, "C": 100, "D": 500, "M": 1000} def A ( _UpperCAmelCase : str ) -> int: '''simple docstring''' _UpperCAmelCase = 0 _UpperCAmelCase = 0 while index < len(_UpperCAmelCase ) - 1: _UpperCAmelCase = SYMBOLS[numerals[index]] _UpperCAmelCase = SYMBOLS[numerals[index + 1]] if current_value < next_value: total_value -= current_value else: total_value += current_value index += 1 total_value += SYMBOLS[numerals[index]] return total_value def A ( _UpperCAmelCase : int ) -> str: '''simple docstring''' _UpperCAmelCase = '' _UpperCAmelCase = num // 1_000 numerals += m_count * "M" num %= 1_000 _UpperCAmelCase = num // 100 if c_count == 9: numerals += "CM" c_count -= 9 elif c_count == 4: numerals += "CD" c_count -= 4 if c_count >= 5: numerals += "D" c_count -= 5 numerals += c_count * "C" num %= 100 _UpperCAmelCase = num // 10 if x_count == 9: numerals += "XC" x_count -= 9 elif x_count == 4: numerals += "XL" x_count -= 4 if x_count >= 5: numerals += "L" x_count -= 5 numerals += x_count * "X" num %= 10 if num == 9: numerals += "IX" num -= 9 elif num == 4: numerals += "IV" num -= 4 if num >= 5: numerals += "V" num -= 5 numerals += num * "I" return numerals def A ( _UpperCAmelCase : str = "/p089_roman.txt" ) -> int: '''simple docstring''' _UpperCAmelCase = 0 with open(os.path.dirname(_UpperCAmelCase ) + roman_numerals_filename ) as filea: _UpperCAmelCase = filea.readlines() for line in lines: _UpperCAmelCase = line.strip() _UpperCAmelCase = parse_roman_numerals(_UpperCAmelCase ) _UpperCAmelCase = generate_roman_numerals(_UpperCAmelCase ) savings += len(_UpperCAmelCase ) - len(_UpperCAmelCase ) return savings if __name__ == "__main__": print(f"""{solution() = }""")
339
1
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
339
import requests from bsa import BeautifulSoup def A ( _UpperCAmelCase : str , _UpperCAmelCase : dict ) -> str: '''simple docstring''' _UpperCAmelCase = BeautifulSoup(requests.get(_UpperCAmelCase , params=_UpperCAmelCase ).content , 'html.parser' ) _UpperCAmelCase = soup.find('div' , attrs={'class': 'gs_ri'} ) _UpperCAmelCase = div.find('div' , attrs={'class': 'gs_fl'} ).find_all('a' ) return anchors[2].get_text() if __name__ == "__main__": UpperCAmelCase__ = { "title": ( "Precisely geometry controlled microsupercapacitors for ultrahigh areal " "capacitance, volumetric capacitance, and energy density" ), "journal": "Chem. Mater.", "volume": 30, "pages": "3979-3990", "year": 2018, "hl": "en", } print(get_citation("https://scholar.google.com/scholar_lookup", params=params))
339
1
import requests from bsa import BeautifulSoup def A ( _UpperCAmelCase : str , _UpperCAmelCase : dict ) -> str: '''simple docstring''' _UpperCAmelCase = BeautifulSoup(requests.get(_UpperCAmelCase , params=_UpperCAmelCase ).content , 'html.parser' ) _UpperCAmelCase = soup.find('div' , attrs={'class': 'gs_ri'} ) _UpperCAmelCase = div.find('div' , attrs={'class': 'gs_fl'} ).find_all('a' ) return anchors[2].get_text() if __name__ == "__main__": UpperCAmelCase__ = { "title": ( "Precisely geometry controlled microsupercapacitors for ultrahigh areal " "capacitance, volumetric capacitance, and energy density" ), "journal": "Chem. Mater.", "volume": 30, "pages": "3979-3990", "year": 2018, "hl": "en", } print(get_citation("https://scholar.google.com/scholar_lookup", params=params))
339
import unittest import numpy as np from transformers import RoFormerConfig, 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.roformer.modeling_flax_roformer import ( FlaxRoFormerForMaskedLM, FlaxRoFormerForMultipleChoice, FlaxRoFormerForQuestionAnswering, FlaxRoFormerForSequenceClassification, FlaxRoFormerForTokenClassification, FlaxRoFormerModel, ) class __lowerCAmelCase ( unittest.TestCase ): def __init__( self : Optional[Any] , A : Dict , A : Union[str, Any]=13 , A : Dict=7 , A : Dict=True , A : Tuple=True , A : Union[str, Any]=True , A : int=True , A : Optional[int]=99 , A : List[str]=32 , A : List[Any]=5 , A : int=4 , A : Any=37 , A : Optional[int]="gelu" , A : Optional[Any]=0.1 , A : Any=0.1 , A : Union[str, Any]=5_12 , A : int=16 , A : List[str]=2 , A : Union[str, Any]=0.0_2 , A : Union[str, Any]=4 , ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = seq_length _UpperCAmelCase = is_training _UpperCAmelCase = use_attention_mask _UpperCAmelCase = use_token_type_ids _UpperCAmelCase = use_labels _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = type_vocab_size _UpperCAmelCase = type_sequence_label_size _UpperCAmelCase = initializer_range _UpperCAmelCase = num_choices def _lowerCamelCase ( self : Optional[Any]) -> List[Any]: """simple docstring""" _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size) _UpperCAmelCase = None if self.use_attention_mask: _UpperCAmelCase = random_attention_mask([self.batch_size, self.seq_length]) _UpperCAmelCase = None if self.use_token_type_ids: _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size) _UpperCAmelCase = RoFormerConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , is_decoder=A , initializer_range=self.initializer_range , ) return config, input_ids, token_type_ids, attention_mask def _lowerCamelCase ( self : List[Any]) -> List[str]: """simple docstring""" _UpperCAmelCase = self.prepare_config_and_inputs() _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = config_and_inputs _UpperCAmelCase = {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': attention_mask} return config, inputs_dict @require_flax class __lowerCAmelCase ( A , unittest.TestCase ): UpperCamelCase = True UpperCamelCase = ( ( FlaxRoFormerModel, FlaxRoFormerForMaskedLM, FlaxRoFormerForSequenceClassification, FlaxRoFormerForTokenClassification, FlaxRoFormerForMultipleChoice, FlaxRoFormerForQuestionAnswering, ) if is_flax_available() else () ) def _lowerCamelCase ( self : Optional[int]) -> Any: """simple docstring""" _UpperCAmelCase = FlaxRoFormerModelTester(self) @slow def _lowerCamelCase ( self : List[Any]) -> Dict: """simple docstring""" for model_class_name in self.all_model_classes: _UpperCAmelCase = model_class_name.from_pretrained('junnyu/roformer_chinese_small' , from_pt=A) _UpperCAmelCase = model(np.ones((1, 1))) self.assertIsNotNone(A) @require_flax class __lowerCAmelCase ( unittest.TestCase ): @slow def _lowerCamelCase ( self : List[Any]) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = FlaxRoFormerForMaskedLM.from_pretrained('junnyu/roformer_chinese_base') _UpperCAmelCase = jnp.array([[0, 1, 2, 3, 4, 5]]) _UpperCAmelCase = model(A)[0] _UpperCAmelCase = 5_00_00 _UpperCAmelCase = (1, 6, vocab_size) self.assertEqual(output.shape , A) _UpperCAmelCase = jnp.array( [[[-0.1_2_0_5, -1.0_2_6_5, 0.2_9_2_2], [-1.5_1_3_4, 0.1_9_7_4, 0.1_5_1_9], [-5.0_1_3_5, -3.9_0_0_3, -0.8_4_0_4]]]) self.assertTrue(jnp.allclose(output[:, :3, :3] , A , atol=1E-4))
339
1
import re from typing import Callable, List, Optional, Union import tensorflow as tf try: from tensorflow.keras.optimizers.legacy import Adam except ImportError: from tensorflow.keras.optimizers import Adam class __lowerCAmelCase ( tf.keras.optimizers.schedules.LearningRateSchedule ): def __init__( self : str , A : float , A : Callable , A : int , A : float = 1.0 , A : str = None , ) -> List[Any]: """simple docstring""" super().__init__() _UpperCAmelCase = initial_learning_rate _UpperCAmelCase = warmup_steps _UpperCAmelCase = power _UpperCAmelCase = decay_schedule_fn _UpperCAmelCase = name def __call__( self : int , A : Optional[int]) -> Dict: """simple docstring""" with tf.name_scope(self.name or 'WarmUp') as name: # Implements polynomial warmup. i.e., if global_step < warmup_steps, the # learning rate will be `global_step/num_warmup_steps * init_lr`. _UpperCAmelCase = tf.cast(A , tf.floataa) _UpperCAmelCase = tf.cast(self.warmup_steps , tf.floataa) _UpperCAmelCase = global_step_float / warmup_steps_float _UpperCAmelCase = self.initial_learning_rate * tf.math.pow(A , self.power) return tf.cond( global_step_float < warmup_steps_float , lambda: warmup_learning_rate , lambda: self.decay_schedule_fn(step - self.warmup_steps) , name=A , ) def _lowerCamelCase ( self : Dict) -> Optional[Any]: """simple docstring""" return { "initial_learning_rate": self.initial_learning_rate, "decay_schedule_fn": self.decay_schedule_fn, "warmup_steps": self.warmup_steps, "power": self.power, "name": self.name, } def A ( _UpperCAmelCase : float , _UpperCAmelCase : int , _UpperCAmelCase : int , _UpperCAmelCase : float = 0.0 , _UpperCAmelCase : float = 0.9 , _UpperCAmelCase : float = 0.999 , _UpperCAmelCase : float = 1E-8 , _UpperCAmelCase : Optional[float] = None , _UpperCAmelCase : Optional[float] = None , _UpperCAmelCase : float = 0.0 , _UpperCAmelCase : float = 1.0 , _UpperCAmelCase : Optional[List[str]] = None , ) -> str: '''simple docstring''' _UpperCAmelCase = tf.keras.optimizers.schedules.PolynomialDecay( initial_learning_rate=_UpperCAmelCase , decay_steps=num_train_steps - num_warmup_steps , end_learning_rate=init_lr * min_lr_ratio , power=_UpperCAmelCase , ) if num_warmup_steps: _UpperCAmelCase = WarmUp( initial_learning_rate=_UpperCAmelCase , decay_schedule_fn=_UpperCAmelCase , warmup_steps=_UpperCAmelCase , ) if weight_decay_rate > 0.0: _UpperCAmelCase = AdamWeightDecay( learning_rate=_UpperCAmelCase , weight_decay_rate=_UpperCAmelCase , beta_a=_UpperCAmelCase , beta_a=_UpperCAmelCase , epsilon=_UpperCAmelCase , clipnorm=_UpperCAmelCase , global_clipnorm=_UpperCAmelCase , exclude_from_weight_decay=['LayerNorm', 'layer_norm', 'bias'] , include_in_weight_decay=_UpperCAmelCase , ) else: _UpperCAmelCase = tf.keras.optimizers.Adam( learning_rate=_UpperCAmelCase , beta_a=_UpperCAmelCase , beta_a=_UpperCAmelCase , epsilon=_UpperCAmelCase , clipnorm=_UpperCAmelCase , global_clipnorm=_UpperCAmelCase , ) # We return the optimizer and the LR scheduler in order to better track the # evolution of the LR independently of the optimizer. return optimizer, lr_schedule class __lowerCAmelCase ( A ): def __init__( self : Optional[Any] , A : Union[float, tf.keras.optimizers.schedules.LearningRateSchedule] = 0.0_0_1 , A : float = 0.9 , A : float = 0.9_9_9 , A : float = 1E-7 , A : bool = False , A : float = 0.0 , A : Optional[List[str]] = None , A : Optional[List[str]] = None , A : str = "AdamWeightDecay" , **A : List[Any] , ) -> List[str]: """simple docstring""" super().__init__(A , A , A , A , A , A , **A) _UpperCAmelCase = weight_decay_rate _UpperCAmelCase = include_in_weight_decay _UpperCAmelCase = exclude_from_weight_decay @classmethod def _lowerCamelCase ( cls : Dict , A : List[str]) -> Tuple: """simple docstring""" _UpperCAmelCase = {'WarmUp': WarmUp} return super(A , cls).from_config(A , custom_objects=A) def _lowerCamelCase ( self : Any , A : Optional[Any] , A : Union[str, Any] , A : List[str]) -> Dict: """simple docstring""" super(A , self)._prepare_local(A , A , A) _UpperCAmelCase = tf.constant( self.weight_decay_rate , name='adam_weight_decay_rate') def _lowerCamelCase ( self : Any , A : str , A : List[str] , A : Any) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = self._do_use_weight_decay(var.name) if do_decay: return var.assign_sub( learning_rate * var * apply_state[(var.device, var.dtype.base_dtype)]['weight_decay_rate'] , use_locking=self._use_locking , ) return tf.no_op() def _lowerCamelCase ( self : List[str] , A : Any , A : int=None , **A : Dict) -> int: """simple docstring""" _UpperCAmelCase , _UpperCAmelCase = list(zip(*A)) return super(A , self).apply_gradients(zip(A , A) , name=A , **A) def _lowerCamelCase ( self : Any , A : Optional[int] , A : Optional[Any] , A : Optional[int]) -> List[Any]: """simple docstring""" if apply_state is None: return self._decayed_lr_t[var_dtype], {} _UpperCAmelCase = apply_state or {} _UpperCAmelCase = apply_state.get((var_device, var_dtype)) if coefficients is None: _UpperCAmelCase = self._fallback_apply_state(A , A) _UpperCAmelCase = coefficients return coefficients["lr_t"], {"apply_state": apply_state} def _lowerCamelCase ( self : Any , A : Dict , A : str , A : Dict=None) -> str: """simple docstring""" _UpperCAmelCase , _UpperCAmelCase = self._get_lr(var.device , var.dtype.base_dtype , A) _UpperCAmelCase = self._decay_weights_op(A , A , A) with tf.control_dependencies([decay]): return super(A , self)._resource_apply_dense(A , A , **A) def _lowerCamelCase ( self : int , A : Union[str, Any] , A : str , A : Optional[int] , A : Optional[int]=None) -> int: """simple docstring""" _UpperCAmelCase , _UpperCAmelCase = self._get_lr(var.device , var.dtype.base_dtype , A) _UpperCAmelCase = self._decay_weights_op(A , A , A) with tf.control_dependencies([decay]): return super(A , self)._resource_apply_sparse(A , A , A , **A) def _lowerCamelCase ( self : List[Any]) -> Tuple: """simple docstring""" _UpperCAmelCase = super().get_config() config.update({'weight_decay_rate': self.weight_decay_rate}) return config def _lowerCamelCase ( self : str , A : Tuple) -> Union[str, Any]: """simple docstring""" if self.weight_decay_rate == 0: return False if self._include_in_weight_decay: for r in self._include_in_weight_decay: if re.search(A , A) is not None: return True if self._exclude_from_weight_decay: for r in self._exclude_from_weight_decay: if re.search(A , A) is not None: return False return True class __lowerCAmelCase ( A ): def __init__( self : List[Any]) -> List[str]: """simple docstring""" _UpperCAmelCase = [] _UpperCAmelCase = None @property def _lowerCamelCase ( self : Any) -> List[Any]: """simple docstring""" if self._accum_steps is None: _UpperCAmelCase = tf.Variable( tf.constant(0 , dtype=tf.intaa) , trainable=A , synchronization=tf.VariableSynchronization.ON_READ , aggregation=tf.VariableAggregation.ONLY_FIRST_REPLICA , ) return self._accum_steps.value() @property def _lowerCamelCase ( self : Optional[int]) -> Dict: """simple docstring""" if not self._gradients: raise ValueError('The accumulator should be called first to initialize the gradients') return [gradient.value() if gradient is not None else gradient for gradient in self._gradients] def __call__( self : Tuple , A : Optional[Any]) -> Any: """simple docstring""" if not self._gradients: _UpperCAmelCase = self.step # Create the step variable. self._gradients.extend( [ tf.Variable( tf.zeros_like(A) , trainable=A , synchronization=tf.VariableSynchronization.ON_READ , aggregation=tf.VariableAggregation.ONLY_FIRST_REPLICA , ) if gradient is not None else gradient for gradient in gradients ]) if len(A) != len(self._gradients): raise ValueError(F"Expected {len(self._gradients)} gradients, but got {len(A)}") for accum_gradient, gradient in zip(self._gradients , A): if accum_gradient is not None and gradient is not None: accum_gradient.assign_add(A) self._accum_steps.assign_add(1) def _lowerCamelCase ( self : str) -> List[Any]: """simple docstring""" if not self._gradients: return self._accum_steps.assign(0) for gradient in self._gradients: if gradient is not None: gradient.assign(tf.zeros_like(A))
339
UpperCAmelCase__ = {} def A ( _UpperCAmelCase : int , _UpperCAmelCase : int , _UpperCAmelCase : int ) -> int: '''simple docstring''' # if we are absent twice, or late 3 consecutive days, # no further prize strings are possible if late == 3 or absent == 2: return 0 # if we have no days left, and have not failed any other rules, # we have a prize string if days == 0: return 1 # No easy solution, so now we need to do the recursive calculation # First, check if the combination is already in the cache, and # if yes, return the stored value from there since we already # know the number of possible prize strings from this point on _UpperCAmelCase = (days, absent, late) if key in cache: return cache[key] # now we calculate the three possible ways that can unfold from # this point on, depending on our attendance today # 1) if we are late (but not absent), the "absent" counter stays as # it is, but the "late" counter increases by one _UpperCAmelCase = _calculate(days - 1 , _UpperCAmelCase , late + 1 ) # 2) if we are absent, the "absent" counter increases by 1, and the # "late" counter resets to 0 _UpperCAmelCase = _calculate(days - 1 , absent + 1 , 0 ) # 3) if we are on time, this resets the "late" counter and keeps the # absent counter _UpperCAmelCase = _calculate(days - 1 , _UpperCAmelCase , 0 ) _UpperCAmelCase = state_late + state_absent + state_ontime _UpperCAmelCase = prizestrings return prizestrings def A ( _UpperCAmelCase : int = 30 ) -> int: '''simple docstring''' return _calculate(_UpperCAmelCase , absent=0 , late=0 ) if __name__ == "__main__": print(solution())
339
1
from collections import defaultdict from math import ceil, sqrt def A ( _UpperCAmelCase : int = 1_000_000 , _UpperCAmelCase : int = 10 ) -> int: '''simple docstring''' _UpperCAmelCase = defaultdict(_UpperCAmelCase ) for outer_width in range(3 , (t_limit // 4) + 2 ): if outer_width * outer_width > t_limit: _UpperCAmelCase = max( ceil(sqrt(outer_width * outer_width - t_limit ) ) , 1 ) else: _UpperCAmelCase = 1 hole_width_lower_bound += (outer_width - hole_width_lower_bound) % 2 for hole_width in range(_UpperCAmelCase , outer_width - 1 , 2 ): count[outer_width * outer_width - hole_width * hole_width] += 1 return sum(1 for n in count.values() if 1 <= n <= 10 ) if __name__ == "__main__": print(f"""{solution() = }""")
339
import os import sys import unittest UpperCAmelCase__ = 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_dummies # noqa: E402 from check_dummies import create_dummy_files, create_dummy_object, find_backend, read_init # noqa: E402 # Align TRANSFORMERS_PATH in check_dummies with the current path UpperCAmelCase__ = os.path.join(git_repo_path, "src", "diffusers") class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Tuple) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = find_backend(' if not is_torch_available():') self.assertEqual(A , 'torch') # backend_with_underscore = find_backend(" if not is_tensorflow_text_available():") # self.assertEqual(backend_with_underscore, "tensorflow_text") _UpperCAmelCase = find_backend(' if not (is_torch_available() and is_transformers_available()):') self.assertEqual(A , 'torch_and_transformers') # double_backend_with_underscore = find_backend( # " if not (is_sentencepiece_available() and is_tensorflow_text_available()):" # ) # self.assertEqual(double_backend_with_underscore, "sentencepiece_and_tensorflow_text") _UpperCAmelCase = find_backend( ' if not (is_torch_available() and is_transformers_available() and is_onnx_available()):') self.assertEqual(A , 'torch_and_transformers_and_onnx') def _lowerCamelCase ( self : int) -> Dict: """simple docstring""" _UpperCAmelCase = read_init() # We don't assert on the exact list of keys to allow for smooth grow of backend-specific objects self.assertIn('torch' , A) self.assertIn('torch_and_transformers' , A) self.assertIn('flax_and_transformers' , A) self.assertIn('torch_and_transformers_and_onnx' , A) # Likewise, we can't assert on the exact content of a key self.assertIn('UNet2DModel' , objects['torch']) self.assertIn('FlaxUNet2DConditionModel' , objects['flax']) self.assertIn('StableDiffusionPipeline' , objects['torch_and_transformers']) self.assertIn('FlaxStableDiffusionPipeline' , objects['flax_and_transformers']) self.assertIn('LMSDiscreteScheduler' , objects['torch_and_scipy']) self.assertIn('OnnxStableDiffusionPipeline' , objects['torch_and_transformers_and_onnx']) def _lowerCamelCase ( self : Union[str, Any]) -> List[Any]: """simple docstring""" _UpperCAmelCase = create_dummy_object('CONSTANT' , '\'torch\'') self.assertEqual(A , '\nCONSTANT = None\n') _UpperCAmelCase = create_dummy_object('function' , '\'torch\'') self.assertEqual( A , '\ndef function(*args, **kwargs):\n requires_backends(function, \'torch\')\n') _UpperCAmelCase = '\nclass FakeClass(metaclass=DummyObject):\n _backends = \'torch\'\n\n def __init__(self, *args, **kwargs):\n requires_backends(self, \'torch\')\n\n @classmethod\n def from_config(cls, *args, **kwargs):\n requires_backends(cls, \'torch\')\n\n @classmethod\n def from_pretrained(cls, *args, **kwargs):\n requires_backends(cls, \'torch\')\n' _UpperCAmelCase = create_dummy_object('FakeClass' , '\'torch\'') self.assertEqual(A , A) def _lowerCamelCase ( self : Dict) -> int: """simple docstring""" _UpperCAmelCase = '# This file is autogenerated by the command `make fix-copies`, do not edit.\nfrom ..utils import DummyObject, requires_backends\n\n\nCONSTANT = None\n\n\ndef function(*args, **kwargs):\n requires_backends(function, ["torch"])\n\n\nclass FakeClass(metaclass=DummyObject):\n _backends = ["torch"]\n\n def __init__(self, *args, **kwargs):\n requires_backends(self, ["torch"])\n\n @classmethod\n def from_config(cls, *args, **kwargs):\n requires_backends(cls, ["torch"])\n\n @classmethod\n def from_pretrained(cls, *args, **kwargs):\n requires_backends(cls, ["torch"])\n' _UpperCAmelCase = create_dummy_files({'torch': ['CONSTANT', 'function', 'FakeClass']}) self.assertEqual(dummy_files['torch'] , A)
339
1
import flax.linen as nn import jax.numpy as jnp from .attention_flax import FlaxTransformeraDModel from .resnet_flax import FlaxDownsampleaD, FlaxResnetBlockaD, FlaxUpsampleaD class __lowerCAmelCase ( nn.Module ): UpperCamelCase = 42 UpperCamelCase = 42 UpperCamelCase = 0.0 UpperCamelCase = 1 UpperCamelCase = 1 UpperCamelCase = True UpperCamelCase = False UpperCamelCase = False UpperCamelCase = False UpperCamelCase = jnp.floataa def _lowerCamelCase ( self : Union[str, Any]) -> int: """simple docstring""" _UpperCAmelCase = [] _UpperCAmelCase = [] for i in range(self.num_layers): _UpperCAmelCase = self.in_channels if i == 0 else self.out_channels _UpperCAmelCase = FlaxResnetBlockaD( in_channels=A , out_channels=self.out_channels , dropout_prob=self.dropout , dtype=self.dtype , ) resnets.append(A) _UpperCAmelCase = FlaxTransformeraDModel( in_channels=self.out_channels , n_heads=self.num_attention_heads , d_head=self.out_channels // self.num_attention_heads , depth=1 , use_linear_projection=self.use_linear_projection , only_cross_attention=self.only_cross_attention , use_memory_efficient_attention=self.use_memory_efficient_attention , dtype=self.dtype , ) attentions.append(A) _UpperCAmelCase = resnets _UpperCAmelCase = attentions if self.add_downsample: _UpperCAmelCase = FlaxDownsampleaD(self.out_channels , dtype=self.dtype) def __call__( self : str , A : List[Any] , A : str , A : int , A : Optional[int]=True) -> List[str]: """simple docstring""" _UpperCAmelCase = () for resnet, attn in zip(self.resnets , self.attentions): _UpperCAmelCase = resnet(A , A , deterministic=A) _UpperCAmelCase = attn(A , A , deterministic=A) output_states += (hidden_states,) if self.add_downsample: _UpperCAmelCase = self.downsamplers_a(A) output_states += (hidden_states,) return hidden_states, output_states class __lowerCAmelCase ( nn.Module ): UpperCamelCase = 42 UpperCamelCase = 42 UpperCamelCase = 0.0 UpperCamelCase = 1 UpperCamelCase = True UpperCamelCase = jnp.floataa def _lowerCamelCase ( self : List[str]) -> str: """simple docstring""" _UpperCAmelCase = [] for i in range(self.num_layers): _UpperCAmelCase = self.in_channels if i == 0 else self.out_channels _UpperCAmelCase = FlaxResnetBlockaD( in_channels=A , out_channels=self.out_channels , dropout_prob=self.dropout , dtype=self.dtype , ) resnets.append(A) _UpperCAmelCase = resnets if self.add_downsample: _UpperCAmelCase = FlaxDownsampleaD(self.out_channels , dtype=self.dtype) def __call__( self : List[Any] , A : Tuple , A : Dict , A : Optional[int]=True) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = () for resnet in self.resnets: _UpperCAmelCase = resnet(A , A , deterministic=A) output_states += (hidden_states,) if self.add_downsample: _UpperCAmelCase = self.downsamplers_a(A) output_states += (hidden_states,) return hidden_states, output_states class __lowerCAmelCase ( nn.Module ): UpperCamelCase = 42 UpperCamelCase = 42 UpperCamelCase = 42 UpperCamelCase = 0.0 UpperCamelCase = 1 UpperCamelCase = 1 UpperCamelCase = True UpperCamelCase = False UpperCamelCase = False UpperCamelCase = False UpperCamelCase = jnp.floataa def _lowerCamelCase ( self : Tuple) -> Optional[int]: """simple docstring""" _UpperCAmelCase = [] _UpperCAmelCase = [] for i in range(self.num_layers): _UpperCAmelCase = self.in_channels if (i == self.num_layers - 1) else self.out_channels _UpperCAmelCase = self.prev_output_channel if i == 0 else self.out_channels _UpperCAmelCase = FlaxResnetBlockaD( in_channels=resnet_in_channels + res_skip_channels , out_channels=self.out_channels , dropout_prob=self.dropout , dtype=self.dtype , ) resnets.append(A) _UpperCAmelCase = FlaxTransformeraDModel( in_channels=self.out_channels , n_heads=self.num_attention_heads , d_head=self.out_channels // self.num_attention_heads , depth=1 , use_linear_projection=self.use_linear_projection , only_cross_attention=self.only_cross_attention , use_memory_efficient_attention=self.use_memory_efficient_attention , dtype=self.dtype , ) attentions.append(A) _UpperCAmelCase = resnets _UpperCAmelCase = attentions if self.add_upsample: _UpperCAmelCase = FlaxUpsampleaD(self.out_channels , dtype=self.dtype) def __call__( self : List[str] , A : Tuple , A : List[Any] , A : List[Any] , A : Tuple , A : Optional[int]=True) -> Tuple: """simple docstring""" for resnet, attn in zip(self.resnets , self.attentions): # pop res hidden states _UpperCAmelCase = res_hidden_states_tuple[-1] _UpperCAmelCase = res_hidden_states_tuple[:-1] _UpperCAmelCase = jnp.concatenate((hidden_states, res_hidden_states) , axis=-1) _UpperCAmelCase = resnet(A , A , deterministic=A) _UpperCAmelCase = attn(A , A , deterministic=A) if self.add_upsample: _UpperCAmelCase = self.upsamplers_a(A) return hidden_states class __lowerCAmelCase ( nn.Module ): UpperCamelCase = 42 UpperCamelCase = 42 UpperCamelCase = 42 UpperCamelCase = 0.0 UpperCamelCase = 1 UpperCamelCase = True UpperCamelCase = jnp.floataa def _lowerCamelCase ( self : Union[str, Any]) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = [] for i in range(self.num_layers): _UpperCAmelCase = self.in_channels if (i == self.num_layers - 1) else self.out_channels _UpperCAmelCase = self.prev_output_channel if i == 0 else self.out_channels _UpperCAmelCase = FlaxResnetBlockaD( in_channels=resnet_in_channels + res_skip_channels , out_channels=self.out_channels , dropout_prob=self.dropout , dtype=self.dtype , ) resnets.append(A) _UpperCAmelCase = resnets if self.add_upsample: _UpperCAmelCase = FlaxUpsampleaD(self.out_channels , dtype=self.dtype) def __call__( self : Any , A : Tuple , A : Any , A : Union[str, Any] , A : Any=True) -> Dict: """simple docstring""" for resnet in self.resnets: # pop res hidden states _UpperCAmelCase = res_hidden_states_tuple[-1] _UpperCAmelCase = res_hidden_states_tuple[:-1] _UpperCAmelCase = jnp.concatenate((hidden_states, res_hidden_states) , axis=-1) _UpperCAmelCase = resnet(A , A , deterministic=A) if self.add_upsample: _UpperCAmelCase = self.upsamplers_a(A) return hidden_states class __lowerCAmelCase ( nn.Module ): UpperCamelCase = 42 UpperCamelCase = 0.0 UpperCamelCase = 1 UpperCamelCase = 1 UpperCamelCase = False UpperCamelCase = False UpperCamelCase = jnp.floataa def _lowerCamelCase ( self : List[Any]) -> str: """simple docstring""" _UpperCAmelCase = [ FlaxResnetBlockaD( in_channels=self.in_channels , out_channels=self.in_channels , dropout_prob=self.dropout , dtype=self.dtype , ) ] _UpperCAmelCase = [] for _ in range(self.num_layers): _UpperCAmelCase = FlaxTransformeraDModel( in_channels=self.in_channels , n_heads=self.num_attention_heads , d_head=self.in_channels // self.num_attention_heads , depth=1 , use_linear_projection=self.use_linear_projection , use_memory_efficient_attention=self.use_memory_efficient_attention , dtype=self.dtype , ) attentions.append(A) _UpperCAmelCase = FlaxResnetBlockaD( in_channels=self.in_channels , out_channels=self.in_channels , dropout_prob=self.dropout , dtype=self.dtype , ) resnets.append(A) _UpperCAmelCase = resnets _UpperCAmelCase = attentions def __call__( self : str , A : List[str] , A : Optional[int] , A : Optional[int] , A : Tuple=True) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = self.resnets[0](A , A) for attn, resnet in zip(self.attentions , self.resnets[1:]): _UpperCAmelCase = attn(A , A , deterministic=A) _UpperCAmelCase = resnet(A , A , deterministic=A) return hidden_states
339
import logging import os import random import sys from dataclasses import dataclass, field from typing import Optional import datasets import numpy as np import pandas as pd from datasets import load_dataset import transformers from transformers import ( AutoConfig, BartForSequenceClassification, DataCollatorWithPadding, EvalPrediction, HfArgumentParser, TapexTokenizer, Trainer, TrainingArguments, default_data_collator, set_seed, ) from transformers.trainer_utils import get_last_checkpoint from transformers.utils import check_min_version from transformers.utils.versions import require_version # Will error if the minimal version of Transformers is not installed. Remove at your own risks. check_min_version("4.17.0.dev0") require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/text-classification/requirements.txt") UpperCAmelCase__ = logging.getLogger(__name__) @dataclass class __lowerCAmelCase : UpperCamelCase = field( default='''tab_fact''' , metadata={'''help''': '''The name of the dataset to use (via the datasets library).'''} ) UpperCamelCase = field( default='''tab_fact''' , metadata={'''help''': '''The configuration name of the dataset to use (via the datasets library).'''} , ) UpperCamelCase = field( default=1_0_2_4 , metadata={ '''help''': ( '''The maximum total input sequence length after tokenization. Sequences longer ''' '''than this will be truncated, sequences shorter will be padded.''' ) } , ) UpperCamelCase = field( default=A , metadata={'''help''': '''Overwrite the cached preprocessed datasets or not.'''} ) UpperCamelCase = field( default=A , 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.''' ) } , ) UpperCamelCase = field( default=A , metadata={ '''help''': ( '''For debugging purposes or quicker training, truncate the number of training examples to this ''' '''value if set.''' ) } , ) UpperCamelCase = field( default=A , metadata={ '''help''': ( '''For debugging purposes or quicker training, truncate the number of evaluation examples to this ''' '''value if set.''' ) } , ) UpperCamelCase = field( default=A , metadata={ '''help''': ( '''For debugging purposes or quicker training, truncate the number of prediction examples to this ''' '''value if set.''' ) } , ) UpperCamelCase = field( default=A , metadata={'''help''': '''A csv or a json file containing the training data.'''} ) UpperCamelCase = field( default=A , metadata={'''help''': '''A csv or a json file containing the validation data.'''} ) UpperCamelCase = field(default=A , metadata={'''help''': '''A csv or a json file containing the test data.'''} ) def _lowerCamelCase ( self : str) -> List[Any]: """simple docstring""" if self.dataset_name is not None: pass elif self.train_file is None or self.validation_file is None: raise ValueError('Need either a GLUE task, a training/validation file or a dataset name.') else: _UpperCAmelCase = self.train_file.split('.')[-1] assert train_extension in ["csv", "json"], "`train_file` should be a csv or a json file." _UpperCAmelCase = self.validation_file.split('.')[-1] assert ( validation_extension == train_extension ), "`validation_file` should have the same extension (csv or json) as `train_file`." @dataclass class __lowerCAmelCase : UpperCamelCase = field( default=A , metadata={'''help''': '''Path to pretrained model or model identifier from huggingface.co/models'''} ) UpperCamelCase = field( default=A , metadata={'''help''': '''Pretrained config name or path if not the same as model_name'''} ) UpperCamelCase = field( default=A , metadata={'''help''': '''Pretrained tokenizer name or path if not the same as model_name'''} ) UpperCamelCase = field( default=A , metadata={'''help''': '''Where do you want to store the pretrained models downloaded from huggingface.co'''} , ) UpperCamelCase = field( default=A , metadata={'''help''': '''Whether to use one of the fast tokenizer (backed by the tokenizers library) or not.'''} , ) UpperCamelCase = field( default='''main''' , metadata={'''help''': '''The specific model version to use (can be a branch name, tag name or commit id).'''} , ) UpperCamelCase = field( default=A , metadata={ '''help''': ( '''Will use the token generated when running `huggingface-cli login` (necessary to use this script ''' '''with private models).''' ) } , ) def A ( ) -> Optional[int]: '''simple docstring''' # See all possible arguments in src/transformers/training_args.py # or by passing the --help flag to this script. # We now keep distinct sets of args, for a cleaner separation of concerns. _UpperCAmelCase = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments) ) if len(sys.argv ) == 2 and sys.argv[1].endswith('.json' ): # If we pass only one argument to the script and it's the path to a json file, # let's parse it to get our arguments. _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1] ) ) else: _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = parser.parse_args_into_dataclasses() # Setup logging logging.basicConfig( format='%(asctime)s - %(levelname)s - %(name)s - %(message)s' , datefmt='%m/%d/%Y %H:%M:%S' , handlers=[logging.StreamHandler(sys.stdout )] , ) _UpperCAmelCase = training_args.get_process_log_level() logger.setLevel(_UpperCAmelCase ) datasets.utils.logging.set_verbosity(_UpperCAmelCase ) transformers.utils.logging.set_verbosity(_UpperCAmelCase ) transformers.utils.logging.enable_default_handler() transformers.utils.logging.enable_explicit_format() # Log on each process the small summary: logger.warning( F"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}" + F"distributed training: {bool(training_args.local_rank != -1 )}, 16-bits training: {training_args.fpaa}" ) logger.info(F"Training/evaluation parameters {training_args}" ) # Detecting last checkpoint. _UpperCAmelCase = None if os.path.isdir(training_args.output_dir ) and training_args.do_train and not training_args.overwrite_output_dir: _UpperCAmelCase = get_last_checkpoint(training_args.output_dir ) if last_checkpoint is None and len(os.listdir(training_args.output_dir ) ) > 0: raise ValueError( F"Output directory ({training_args.output_dir}) already exists and is not empty. " 'Use --overwrite_output_dir to overcome.' ) elif last_checkpoint is not None and training_args.resume_from_checkpoint is None: logger.info( F"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change " 'the `--output_dir` or add `--overwrite_output_dir` to train from scratch.' ) # Set seed before initializing model. set_seed(training_args.seed ) # Get the datasets: you can either provide your own CSV/JSON training and evaluation files (see below) # or specify a GLUE benchmark task (the dataset will be downloaded automatically from the datasets Hub). # # For JSON files, this script will use the `question` column for the input question and `table` column for the corresponding table. # # If the CSVs/JSONs contain only one non-label column, the script does single sentence classification on this # single column. You can easily tweak this behavior (see below) # # In distributed training, the load_dataset function guarantee that only one local process can concurrently # download the dataset. if data_args.dataset_name is not None: # Downloading and loading a dataset from the hub. _UpperCAmelCase = load_dataset( data_args.dataset_name , data_args.dataset_config_name , cache_dir=model_args.cache_dir ) else: # Loading a dataset from your local files. # CSV/JSON training and evaluation files are needed. _UpperCAmelCase = {'train': data_args.train_file, 'validation': data_args.validation_file} # Get the test dataset: you can provide your own CSV/JSON test file (see below) # when you use `do_predict` without specifying a GLUE benchmark task. if training_args.do_predict: if data_args.test_file is not None: _UpperCAmelCase = data_args.train_file.split('.' )[-1] _UpperCAmelCase = data_args.test_file.split('.' )[-1] assert ( test_extension == train_extension ), "`test_file` should have the same extension (csv or json) as `train_file`." _UpperCAmelCase = data_args.test_file else: raise ValueError('Need either a GLUE task or a test file for `do_predict`.' ) for key in data_files.keys(): logger.info(F"load a local file for {key}: {data_files[key]}" ) if data_args.train_file.endswith('.csv' ): # Loading a dataset from local csv files _UpperCAmelCase = load_dataset('csv' , data_files=_UpperCAmelCase , cache_dir=model_args.cache_dir ) else: # Loading a dataset from local json files _UpperCAmelCase = load_dataset('json' , data_files=_UpperCAmelCase , cache_dir=model_args.cache_dir ) # See more about loading any type of standard or custom dataset at # https://huggingface.co/docs/datasets/loading_datasets.html. # Labels _UpperCAmelCase = raw_datasets['train'].features['label'].names _UpperCAmelCase = len(_UpperCAmelCase ) # Load pretrained model and tokenizer # # In distributed training, the .from_pretrained methods guarantee that only one local process can concurrently # download model & vocab. _UpperCAmelCase = AutoConfig.from_pretrained( model_args.config_name if model_args.config_name else model_args.model_name_or_path , num_labels=_UpperCAmelCase , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , ) # load tapex tokenizer _UpperCAmelCase = TapexTokenizer.from_pretrained( model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path , cache_dir=model_args.cache_dir , use_fast=model_args.use_fast_tokenizer , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , add_prefix_space=_UpperCAmelCase , ) _UpperCAmelCase = BartForSequenceClassification.from_pretrained( model_args.model_name_or_path , from_tf=bool('.ckpt' in model_args.model_name_or_path ) , config=_UpperCAmelCase , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , ) # Padding strategy if data_args.pad_to_max_length: _UpperCAmelCase = 'max_length' else: # We will pad later, dynamically at batch creation, to the max sequence length in each batch _UpperCAmelCase = False # Some models have set the order of the labels to use, so let's make sure we do use it. _UpperCAmelCase = {'Refused': 0, 'Entailed': 1} _UpperCAmelCase = {0: 'Refused', 1: 'Entailed'} if data_args.max_seq_length > tokenizer.model_max_length: logger.warning( F"The max_seq_length passed ({data_args.max_seq_length}) is larger than the maximum length for the" F"model ({tokenizer.model_max_length}). Using max_seq_length={tokenizer.model_max_length}." ) _UpperCAmelCase = min(data_args.max_seq_length , tokenizer.model_max_length ) def preprocess_tabfact_function(_UpperCAmelCase : Union[str, Any] ): # Tokenize the texts def _convert_table_text_to_pandas(_UpperCAmelCase : Dict ): _UpperCAmelCase = [_table_row.split('#' ) for _table_row in _table_text.strip('\n' ).split('\n' )] _UpperCAmelCase = pd.DataFrame.from_records(_table_content[1:] , columns=_table_content[0] ) return _table_pd _UpperCAmelCase = examples['statement'] _UpperCAmelCase = list(map(_convert_table_text_to_pandas , examples['table_text'] ) ) _UpperCAmelCase = tokenizer(_UpperCAmelCase , _UpperCAmelCase , padding=_UpperCAmelCase , max_length=_UpperCAmelCase , truncation=_UpperCAmelCase ) _UpperCAmelCase = examples['label'] return result with training_args.main_process_first(desc='dataset map pre-processing' ): _UpperCAmelCase = raw_datasets.map( _UpperCAmelCase , batched=_UpperCAmelCase , load_from_cache_file=not data_args.overwrite_cache , desc='Running tokenizer on dataset' , ) if training_args.do_train: if "train" not in raw_datasets: raise ValueError('--do_train requires a train dataset' ) _UpperCAmelCase = raw_datasets['train'] if data_args.max_train_samples is not None: _UpperCAmelCase = train_dataset.select(range(data_args.max_train_samples ) ) if training_args.do_eval: if "validation" not in raw_datasets and "validation_matched" not in raw_datasets: raise ValueError('--do_eval requires a validation dataset' ) _UpperCAmelCase = raw_datasets['validation'] if data_args.max_eval_samples is not None: _UpperCAmelCase = eval_dataset.select(range(data_args.max_eval_samples ) ) if training_args.do_predict or data_args.test_file is not None: if "test" not in raw_datasets and "test_matched" not in raw_datasets: raise ValueError('--do_predict requires a test dataset' ) _UpperCAmelCase = raw_datasets['test'] if data_args.max_predict_samples is not None: _UpperCAmelCase = predict_dataset.select(range(data_args.max_predict_samples ) ) # Log a few random samples from the training set: if training_args.do_train: for index in random.sample(range(len(_UpperCAmelCase ) ) , 3 ): logger.info(F"Sample {index} of the training set: {train_dataset[index]}." ) # You can define your custom compute_metrics function. It takes an `EvalPrediction` object (a namedtuple with a # predictions and label_ids field) and has to return a dictionary string to float. def compute_metrics(_UpperCAmelCase : EvalPrediction ): _UpperCAmelCase = p.predictions[0] if isinstance(p.predictions , _UpperCAmelCase ) else p.predictions _UpperCAmelCase = np.argmax(_UpperCAmelCase , axis=1 ) return {"accuracy": (preds == p.label_ids).astype(np.floataa ).mean().item()} # Data collator will default to DataCollatorWithPadding, so we change it if we already did the padding. if data_args.pad_to_max_length: _UpperCAmelCase = default_data_collator elif training_args.fpaa: _UpperCAmelCase = DataCollatorWithPadding(_UpperCAmelCase , pad_to_multiple_of=8 ) else: _UpperCAmelCase = None # Initialize our Trainer _UpperCAmelCase = Trainer( model=_UpperCAmelCase , args=_UpperCAmelCase , train_dataset=train_dataset if training_args.do_train else None , eval_dataset=eval_dataset if training_args.do_eval else None , compute_metrics=_UpperCAmelCase , tokenizer=_UpperCAmelCase , data_collator=_UpperCAmelCase , ) # Training if training_args.do_train: _UpperCAmelCase = None if training_args.resume_from_checkpoint is not None: _UpperCAmelCase = training_args.resume_from_checkpoint elif last_checkpoint is not None: _UpperCAmelCase = last_checkpoint _UpperCAmelCase = trainer.train(resume_from_checkpoint=_UpperCAmelCase ) _UpperCAmelCase = train_result.metrics _UpperCAmelCase = ( data_args.max_train_samples if data_args.max_train_samples is not None else len(_UpperCAmelCase ) ) _UpperCAmelCase = min(_UpperCAmelCase , len(_UpperCAmelCase ) ) trainer.save_model() # Saves the tokenizer too for easy upload trainer.log_metrics('train' , _UpperCAmelCase ) trainer.save_metrics('train' , _UpperCAmelCase ) trainer.save_state() # Evaluation if training_args.do_eval: logger.info('*** Evaluate ***' ) _UpperCAmelCase = trainer.evaluate(eval_dataset=_UpperCAmelCase ) _UpperCAmelCase = data_args.max_eval_samples if data_args.max_eval_samples is not None else len(_UpperCAmelCase ) _UpperCAmelCase = min(_UpperCAmelCase , len(_UpperCAmelCase ) ) trainer.log_metrics('eval' , _UpperCAmelCase ) trainer.save_metrics('eval' , _UpperCAmelCase ) if training_args.do_predict: logger.info('*** Predict ***' ) # Removing the `label` columns because it contains -1 and Trainer won't like that. _UpperCAmelCase = predict_dataset.remove_columns('label' ) _UpperCAmelCase = trainer.predict(_UpperCAmelCase , metric_key_prefix='predict' ).predictions _UpperCAmelCase = np.argmax(_UpperCAmelCase , axis=1 ) _UpperCAmelCase = os.path.join(training_args.output_dir , 'predict_results_tabfact.txt' ) if trainer.is_world_process_zero(): with open(_UpperCAmelCase , 'w' ) as writer: logger.info('***** Predict Results *****' ) writer.write('index\tprediction\n' ) for index, item in enumerate(_UpperCAmelCase ): _UpperCAmelCase = label_list[item] writer.write(F"{index}\t{item}\n" ) _UpperCAmelCase = {'finetuned_from': model_args.model_name_or_path, 'tasks': 'text-classification'} if training_args.push_to_hub: trainer.push_to_hub(**_UpperCAmelCase ) else: trainer.create_model_card(**_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[Any] ) -> Optional[Any]: '''simple docstring''' # For xla_spawn (TPUs) main() if __name__ == "__main__": main()
339
1
import logging import os from dataclasses import dataclass, field from functools import partial from pathlib import Path from tempfile import TemporaryDirectory from typing import List, Optional import faiss import torch from datasets import Features, Sequence, Value, load_dataset from transformers import DPRContextEncoder, DPRContextEncoderTokenizerFast, HfArgumentParser UpperCAmelCase__ = logging.getLogger(__name__) torch.set_grad_enabled(False) UpperCAmelCase__ = "cuda" if torch.cuda.is_available() else "cpu" def A ( _UpperCAmelCase : str , _UpperCAmelCase : Optional[Any]=100 , _UpperCAmelCase : Tuple=" " ) -> List[str]: '''simple docstring''' _UpperCAmelCase = text.split(_UpperCAmelCase ) return [character.join(text[i : i + n] ).strip() for i in range(0 , len(_UpperCAmelCase ) , _UpperCAmelCase )] def A ( _UpperCAmelCase : dict ) -> dict: '''simple docstring''' _UpperCAmelCase , _UpperCAmelCase = [], [] for title, text in zip(documents['title'] , documents['text'] ): if text is not None: for passage in split_text(_UpperCAmelCase ): titles.append(title if title is not None else '' ) texts.append(_UpperCAmelCase ) return {"title": titles, "text": texts} def A ( _UpperCAmelCase : dict , _UpperCAmelCase : DPRContextEncoder , _UpperCAmelCase : DPRContextEncoderTokenizerFast ) -> dict: '''simple docstring''' _UpperCAmelCase = ctx_tokenizer( documents['title'] , documents['text'] , truncation=_UpperCAmelCase , padding='longest' , return_tensors='pt' )['input_ids'] _UpperCAmelCase = ctx_encoder(input_ids.to(device=_UpperCAmelCase ) , return_dict=_UpperCAmelCase ).pooler_output return {"embeddings": embeddings.detach().cpu().numpy()} def A ( _UpperCAmelCase : "RagExampleArguments" , _UpperCAmelCase : "ProcessingArguments" , _UpperCAmelCase : "IndexHnswArguments" , ) -> Tuple: '''simple docstring''' ###################################### logger.info('Step 1 - Create the dataset' ) ###################################### # The dataset needed for RAG must have three columns: # - title (string): title of the document # - text (string): text of a passage of the document # - embeddings (array of dimension d): DPR representation of the passage # Let's say you have documents in tab-separated csv files with columns "title" and "text" assert os.path.isfile(rag_example_args.csv_path ), "Please provide a valid path to a csv file" # You can load a Dataset object this way _UpperCAmelCase = load_dataset( 'csv' , data_files=[rag_example_args.csv_path] , split='train' , delimiter='\t' , column_names=['title', 'text'] ) # More info about loading csv files in the documentation: https://huggingface.co/docs/datasets/loading_datasets.html?highlight=csv#csv-files # Then split the documents into passages of 100 words _UpperCAmelCase = dataset.map(_UpperCAmelCase , batched=_UpperCAmelCase , num_proc=processing_args.num_proc ) # And compute the embeddings _UpperCAmelCase = DPRContextEncoder.from_pretrained(rag_example_args.dpr_ctx_encoder_model_name ).to(device=_UpperCAmelCase ) _UpperCAmelCase = DPRContextEncoderTokenizerFast.from_pretrained(rag_example_args.dpr_ctx_encoder_model_name ) _UpperCAmelCase = Features( {'text': Value('string' ), 'title': Value('string' ), 'embeddings': Sequence(Value('float32' ) )} ) # optional, save as float32 instead of float64 to save space _UpperCAmelCase = dataset.map( partial(_UpperCAmelCase , ctx_encoder=_UpperCAmelCase , ctx_tokenizer=_UpperCAmelCase ) , batched=_UpperCAmelCase , batch_size=processing_args.batch_size , features=_UpperCAmelCase , ) # And finally save your dataset _UpperCAmelCase = os.path.join(rag_example_args.output_dir , 'my_knowledge_dataset' ) dataset.save_to_disk(_UpperCAmelCase ) # from datasets import load_from_disk # dataset = load_from_disk(passages_path) # to reload the dataset ###################################### logger.info('Step 2 - Index the dataset' ) ###################################### # Let's use the Faiss implementation of HNSW for fast approximate nearest neighbor search _UpperCAmelCase = faiss.IndexHNSWFlat(index_hnsw_args.d , index_hnsw_args.m , faiss.METRIC_INNER_PRODUCT ) dataset.add_faiss_index('embeddings' , custom_index=_UpperCAmelCase ) # And save the index _UpperCAmelCase = os.path.join(rag_example_args.output_dir , 'my_knowledge_dataset_hnsw_index.faiss' ) dataset.get_index('embeddings' ).save(_UpperCAmelCase ) # dataset.load_faiss_index("embeddings", index_path) # to reload the index @dataclass class __lowerCAmelCase : UpperCamelCase = field( default=str(Path(A ).parent / '''test_run''' / '''dummy-kb''' / '''my_knowledge_dataset.csv''' ) , metadata={'''help''': '''Path to a tab-separated csv file with columns \'title\' and \'text\''''} , ) UpperCamelCase = field( default=A , metadata={'''help''': '''Question that is passed as input to RAG. Default is \'What does Moses\' rod turn into ?\'.'''} , ) UpperCamelCase = field( default='''facebook/rag-sequence-nq''' , metadata={'''help''': '''The RAG model to use. Either \'facebook/rag-sequence-nq\' or \'facebook/rag-token-nq\''''} , ) UpperCamelCase = field( default='''facebook/dpr-ctx_encoder-multiset-base''' , metadata={ '''help''': ( '''The DPR context encoder model to use. Either \'facebook/dpr-ctx_encoder-single-nq-base\' or''' ''' \'facebook/dpr-ctx_encoder-multiset-base\'''' ) } , ) UpperCamelCase = field( default=str(Path(A ).parent / '''test_run''' / '''dummy-kb''' ) , metadata={'''help''': '''Path to a directory where the dataset passages and the index will be saved'''} , ) @dataclass class __lowerCAmelCase : UpperCamelCase = field( default=A , metadata={ '''help''': '''The number of processes to use to split the documents into passages. Default is single process.''' } , ) UpperCamelCase = field( default=1_6 , metadata={ '''help''': '''The batch size to use when computing the passages embeddings using the DPR context encoder.''' } , ) @dataclass class __lowerCAmelCase : UpperCamelCase = field( default=7_6_8 , metadata={'''help''': '''The dimension of the embeddings to pass to the HNSW Faiss index.'''} , ) UpperCamelCase = field( default=1_2_8 , metadata={ '''help''': ( '''The number of bi-directional links created for every new element during the HNSW index construction.''' ) } , ) if __name__ == "__main__": logging.basicConfig(level=logging.WARNING) logger.setLevel(logging.INFO) UpperCAmelCase__ = HfArgumentParser((RagExampleArguments, ProcessingArguments, IndexHnswArguments)) UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = parser.parse_args_into_dataclasses() with TemporaryDirectory() as tmp_dir: UpperCAmelCase__ = rag_example_args.output_dir or tmp_dir main(rag_example_args, processing_args, index_hnsw_args)
339
# This code is adapted from OpenAI's release # https://github.com/openai/human-eval/blob/master/human_eval/execution.py import contextlib import faulthandler import io import multiprocessing import os import platform import signal import tempfile def A ( _UpperCAmelCase : Union[str, Any] , _UpperCAmelCase : Dict , _UpperCAmelCase : Dict , _UpperCAmelCase : Dict ) -> Any: '''simple docstring''' _UpperCAmelCase = multiprocessing.Manager() _UpperCAmelCase = manager.list() _UpperCAmelCase = multiprocessing.Process(target=_UpperCAmelCase , args=(check_program, result, timeout) ) p.start() p.join(timeout=timeout + 1 ) if p.is_alive(): p.kill() if not result: result.append('timed out' ) return { "task_id": task_id, "passed": result[0] == "passed", "result": result[0], "completion_id": completion_id, } def A ( _UpperCAmelCase : str , _UpperCAmelCase : List[str] , _UpperCAmelCase : Dict ) -> Optional[int]: '''simple docstring''' with create_tempdir(): # These system calls are needed when cleaning up tempdir. import os import shutil _UpperCAmelCase = shutil.rmtree _UpperCAmelCase = os.rmdir _UpperCAmelCase = os.chdir # Disable functionalities that can make destructive changes to the test. reliability_guard() # Run program. try: _UpperCAmelCase = {} with swallow_io(): with time_limit(_UpperCAmelCase ): exec(_UpperCAmelCase , _UpperCAmelCase ) result.append('passed' ) except TimeoutException: result.append('timed out' ) except BaseException as e: result.append(F"failed: {e}" ) # Needed for cleaning up. _UpperCAmelCase = rmtree _UpperCAmelCase = rmdir _UpperCAmelCase = chdir @contextlib.contextmanager def A ( _UpperCAmelCase : Union[str, Any] ) -> Any: '''simple docstring''' def signal_handler(_UpperCAmelCase : List[Any] , _UpperCAmelCase : Dict ): raise TimeoutException('Timed out!' ) signal.setitimer(signal.ITIMER_REAL , _UpperCAmelCase ) signal.signal(signal.SIGALRM , _UpperCAmelCase ) try: yield finally: signal.setitimer(signal.ITIMER_REAL , 0 ) @contextlib.contextmanager def A ( ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = WriteOnlyStringIO() with contextlib.redirect_stdout(_UpperCAmelCase ): with contextlib.redirect_stderr(_UpperCAmelCase ): with redirect_stdin(_UpperCAmelCase ): yield @contextlib.contextmanager def A ( ) -> Any: '''simple docstring''' with tempfile.TemporaryDirectory() as dirname: with chdir(_UpperCAmelCase ): yield dirname class __lowerCAmelCase ( A ): pass class __lowerCAmelCase ( io.StringIO ): def _lowerCamelCase ( self : Tuple , *A : str , **A : Any) -> Any: """simple docstring""" raise OSError def _lowerCamelCase ( self : List[str] , *A : Optional[Any] , **A : Optional[Any]) -> Optional[int]: """simple docstring""" raise OSError def _lowerCamelCase ( self : str , *A : List[str] , **A : List[Any]) -> Union[str, Any]: """simple docstring""" raise OSError def _lowerCamelCase ( self : Union[str, Any] , *A : Optional[Any] , **A : List[str]) -> Optional[int]: """simple docstring""" return False class __lowerCAmelCase ( contextlib._RedirectStream ): # type: ignore UpperCamelCase = '''stdin''' @contextlib.contextmanager def A ( _UpperCAmelCase : List[Any] ) -> Dict: '''simple docstring''' if root == ".": yield return _UpperCAmelCase = os.getcwd() os.chdir(_UpperCAmelCase ) try: yield except BaseException as exc: raise exc finally: os.chdir(_UpperCAmelCase ) def A ( _UpperCAmelCase : List[str]=None ) -> Any: '''simple docstring''' if maximum_memory_bytes is not None: import resource resource.setrlimit(resource.RLIMIT_AS , (maximum_memory_bytes, maximum_memory_bytes) ) resource.setrlimit(resource.RLIMIT_DATA , (maximum_memory_bytes, maximum_memory_bytes) ) if not platform.uname().system == "Darwin": resource.setrlimit(resource.RLIMIT_STACK , (maximum_memory_bytes, maximum_memory_bytes) ) faulthandler.disable() import builtins _UpperCAmelCase = None _UpperCAmelCase = None import os _UpperCAmelCase = '1' _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None import shutil _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None import subprocess _UpperCAmelCase = None # type: ignore _UpperCAmelCase = None import sys _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None
339
1
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available UpperCAmelCase__ = { "configuration_transfo_xl": ["TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP", "TransfoXLConfig"], "tokenization_transfo_xl": ["TransfoXLCorpus", "TransfoXLTokenizer"], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase__ = [ "TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST", "AdaptiveEmbedding", "TransfoXLForSequenceClassification", "TransfoXLLMHeadModel", "TransfoXLModel", "TransfoXLPreTrainedModel", "load_tf_weights_in_transfo_xl", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase__ = [ "TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST", "TFAdaptiveEmbedding", "TFTransfoXLForSequenceClassification", "TFTransfoXLLMHeadModel", "TFTransfoXLMainLayer", "TFTransfoXLModel", "TFTransfoXLPreTrainedModel", ] if TYPE_CHECKING: from .configuration_transfo_xl import TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, TransfoXLConfig from .tokenization_transfo_xl import TransfoXLCorpus, TransfoXLTokenizer try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_transfo_xl import ( TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST, AdaptiveEmbedding, TransfoXLForSequenceClassification, TransfoXLLMHeadModel, TransfoXLModel, TransfoXLPreTrainedModel, load_tf_weights_in_transfo_xl, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_transfo_xl import ( TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST, TFAdaptiveEmbedding, TFTransfoXLForSequenceClassification, TFTransfoXLLMHeadModel, TFTransfoXLMainLayer, TFTransfoXLModel, TFTransfoXLPreTrainedModel, ) else: import sys UpperCAmelCase__ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
339
import asyncio import os import shutil import subprocess import sys import tempfile import unittest from distutils.util import strtobool from functools import partial from pathlib import Path from typing import List, Union from unittest import mock import torch from ..state import AcceleratorState, PartialState from ..utils import ( gather, is_bnb_available, is_comet_ml_available, is_datasets_available, is_deepspeed_available, is_mps_available, is_safetensors_available, is_tensorboard_available, is_torch_version, is_tpu_available, is_transformers_available, is_wandb_available, is_xpu_available, ) def A ( _UpperCAmelCase : Tuple , _UpperCAmelCase : Union[str, Any]=False ) -> str: '''simple docstring''' try: _UpperCAmelCase = os.environ[key] except KeyError: # KEY isn't set, default to `default`. _UpperCAmelCase = default else: # KEY is set, convert it to True or False. try: _UpperCAmelCase = strtobool(_UpperCAmelCase ) except ValueError: # More values are supported, but let's keep the message simple. raise ValueError(F"If set, {key} must be yes or no." ) return _value UpperCAmelCase__ = parse_flag_from_env("RUN_SLOW", default=False) def A ( _UpperCAmelCase : List[str] ) -> List[str]: '''simple docstring''' return unittest.skip('Test was skipped' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Dict ) -> str: '''simple docstring''' return unittest.skipUnless(_run_slow_tests , 'test is slow' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Any ) -> str: '''simple docstring''' return unittest.skipUnless(not torch.cuda.is_available() , 'test requires only a CPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Dict ) -> Dict: '''simple docstring''' return unittest.skipUnless(torch.cuda.is_available() , 'test requires a GPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[Any] ) -> List[Any]: '''simple docstring''' return unittest.skipUnless(is_xpu_available() , 'test requires a XPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[int] ) -> List[str]: '''simple docstring''' return unittest.skipUnless(is_mps_available() , 'test requires a `mps` backend support in `torch`' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Union[str, Any] ) -> List[Any]: '''simple docstring''' return unittest.skipUnless( is_transformers_available() and is_datasets_available() , 'test requires the Hugging Face suite' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : str ) -> str: '''simple docstring''' return unittest.skipUnless(is_bnb_available() , 'test requires the bitsandbytes library' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Union[str, Any] ) -> List[Any]: '''simple docstring''' return unittest.skipUnless(is_tpu_available() , 'test requires TPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[Any] ) -> str: '''simple docstring''' return unittest.skipUnless(torch.cuda.device_count() == 1 , 'test requires a GPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Tuple ) -> int: '''simple docstring''' return unittest.skipUnless(torch.xpu.device_count() == 1 , 'test requires a XPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Any ) -> Optional[int]: '''simple docstring''' return unittest.skipUnless(torch.cuda.device_count() > 1 , 'test requires multiple GPUs' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Tuple ) -> Any: '''simple docstring''' return unittest.skipUnless(torch.xpu.device_count() > 1 , 'test requires multiple XPUs' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Any ) -> Optional[int]: '''simple docstring''' return unittest.skipUnless(is_safetensors_available() , 'test requires safetensors' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : List[Any] ) -> Dict: '''simple docstring''' return unittest.skipUnless(is_deepspeed_available() , 'test requires DeepSpeed' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[int] ) -> str: '''simple docstring''' return unittest.skipUnless(is_torch_version('>=' , '1.12.0' ) , 'test requires torch version >= 1.12.0' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Any=None , _UpperCAmelCase : List[Any]=None ) -> Dict: '''simple docstring''' if test_case is None: return partial(_UpperCAmelCase , version=_UpperCAmelCase ) return unittest.skipUnless(is_torch_version('>=' , _UpperCAmelCase ) , F"test requires torch version >= {version}" )(_UpperCAmelCase ) def A ( _UpperCAmelCase : List[str] ) -> int: '''simple docstring''' return unittest.skipUnless(is_tensorboard_available() , 'test requires Tensorboard' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Union[str, Any] ) -> Union[str, Any]: '''simple docstring''' return unittest.skipUnless(is_wandb_available() , 'test requires wandb' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : List[str] ) -> Optional[int]: '''simple docstring''' return unittest.skipUnless(is_comet_ml_available() , 'test requires comet_ml' )(_UpperCAmelCase ) UpperCAmelCase__ = ( any([is_wandb_available(), is_tensorboard_available()]) and not is_comet_ml_available() ) def A ( _UpperCAmelCase : List[str] ) -> Any: '''simple docstring''' return unittest.skipUnless( _atleast_one_tracker_available , 'test requires at least one tracker to be available and for `comet_ml` to not be installed' , )(_UpperCAmelCase ) class __lowerCAmelCase ( unittest.TestCase ): UpperCamelCase = True @classmethod def _lowerCamelCase ( cls : List[Any]) -> Tuple: """simple docstring""" _UpperCAmelCase = tempfile.mkdtemp() @classmethod def _lowerCamelCase ( cls : Union[str, Any]) -> str: """simple docstring""" if os.path.exists(cls.tmpdir): shutil.rmtree(cls.tmpdir) def _lowerCamelCase ( self : List[str]) -> List[Any]: """simple docstring""" if self.clear_on_setup: for path in Path(self.tmpdir).glob('**/*'): if path.is_file(): path.unlink() elif path.is_dir(): shutil.rmtree(A) class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Dict) -> Tuple: """simple docstring""" super().tearDown() # Reset the state of the AcceleratorState singleton. AcceleratorState._reset_state() PartialState._reset_state() class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Optional[int] , A : Union[mock.Mock, List[mock.Mock]]) -> Tuple: """simple docstring""" _UpperCAmelCase = mocks if isinstance(A , (tuple, list)) else [mocks] for m in self.mocks: m.start() self.addCleanup(m.stop) def A ( _UpperCAmelCase : List[Any] ) -> int: '''simple docstring''' _UpperCAmelCase = AcceleratorState() _UpperCAmelCase = tensor[None].clone().to(state.device ) _UpperCAmelCase = gather(_UpperCAmelCase ).cpu() _UpperCAmelCase = tensor[0].cpu() for i in range(tensors.shape[0] ): if not torch.equal(tensors[i] , _UpperCAmelCase ): return False return True class __lowerCAmelCase : def __init__( self : Optional[Any] , A : Union[str, Any] , A : Optional[int] , A : str) -> Optional[int]: """simple docstring""" _UpperCAmelCase = returncode _UpperCAmelCase = stdout _UpperCAmelCase = stderr async def A ( _UpperCAmelCase : str , _UpperCAmelCase : Optional[int] ) -> Optional[Any]: '''simple docstring''' while True: _UpperCAmelCase = await stream.readline() if line: callback(_UpperCAmelCase ) else: break async def A ( _UpperCAmelCase : Optional[int] , _UpperCAmelCase : List[str]=None , _UpperCAmelCase : str=None , _UpperCAmelCase : str=None , _UpperCAmelCase : Dict=False , _UpperCAmelCase : Union[str, Any]=False ) -> _RunOutput: '''simple docstring''' if echo: print('\nRunning: ' , ' '.join(_UpperCAmelCase ) ) _UpperCAmelCase = await asyncio.create_subprocess_exec( cmd[0] , *cmd[1:] , stdin=_UpperCAmelCase , stdout=asyncio.subprocess.PIPE , stderr=asyncio.subprocess.PIPE , env=_UpperCAmelCase , ) # note: there is a warning for a possible deadlock when using `wait` with huge amounts of data in the pipe # https://docs.python.org/3/library/asyncio-subprocess.html#asyncio.asyncio.subprocess.Process.wait # # If it starts hanging, will need to switch to the following code. The problem is that no data # will be seen until it's done and if it hangs for example there will be no debug info. # out, err = await p.communicate() # return _RunOutput(p.returncode, out, err) _UpperCAmelCase = [] _UpperCAmelCase = [] def tee(_UpperCAmelCase : Union[str, Any] , _UpperCAmelCase : List[Any] , _UpperCAmelCase : str , _UpperCAmelCase : str="" ): _UpperCAmelCase = line.decode('utf-8' ).rstrip() sink.append(_UpperCAmelCase ) if not quiet: print(_UpperCAmelCase , _UpperCAmelCase , file=_UpperCAmelCase ) # XXX: the timeout doesn't seem to make any difference here await asyncio.wait( [ asyncio.create_task(_read_stream(p.stdout , lambda _UpperCAmelCase : tee(_UpperCAmelCase , _UpperCAmelCase , sys.stdout , label='stdout:' ) ) ), asyncio.create_task(_read_stream(p.stderr , lambda _UpperCAmelCase : tee(_UpperCAmelCase , _UpperCAmelCase , sys.stderr , label='stderr:' ) ) ), ] , timeout=_UpperCAmelCase , ) return _RunOutput(await p.wait() , _UpperCAmelCase , _UpperCAmelCase ) def A ( _UpperCAmelCase : str , _UpperCAmelCase : Dict=None , _UpperCAmelCase : str=None , _UpperCAmelCase : str=180 , _UpperCAmelCase : List[Any]=False , _UpperCAmelCase : List[Any]=True ) -> _RunOutput: '''simple docstring''' _UpperCAmelCase = asyncio.get_event_loop() _UpperCAmelCase = loop.run_until_complete( _stream_subprocess(_UpperCAmelCase , env=_UpperCAmelCase , stdin=_UpperCAmelCase , timeout=_UpperCAmelCase , quiet=_UpperCAmelCase , echo=_UpperCAmelCase ) ) _UpperCAmelCase = ' '.join(_UpperCAmelCase ) if result.returncode > 0: _UpperCAmelCase = '\n'.join(result.stderr ) raise RuntimeError( F"'{cmd_str}' failed with returncode {result.returncode}\n\n" F"The combined stderr from workers follows:\n{stderr}" ) return result class __lowerCAmelCase ( A ): pass def A ( _UpperCAmelCase : List[str] , _UpperCAmelCase : str=False ) -> Tuple: '''simple docstring''' try: _UpperCAmelCase = subprocess.check_output(_UpperCAmelCase , stderr=subprocess.STDOUT ) if return_stdout: if hasattr(_UpperCAmelCase , 'decode' ): _UpperCAmelCase = output.decode('utf-8' ) return output except subprocess.CalledProcessError as e: raise SubprocessCallException( F"Command `{' '.join(_UpperCAmelCase )}` failed with the following error:\n\n{e.output.decode()}" ) from e
339
1
def A ( _UpperCAmelCase : int ) -> bool: '''simple docstring''' return str(_UpperCAmelCase ) == str(_UpperCAmelCase )[::-1] def A ( _UpperCAmelCase : int ) -> int: '''simple docstring''' return int(_UpperCAmelCase ) + int(str(_UpperCAmelCase )[::-1] ) def A ( _UpperCAmelCase : int = 10_000 ) -> int: '''simple docstring''' _UpperCAmelCase = [] for num in range(1 , _UpperCAmelCase ): _UpperCAmelCase = 0 _UpperCAmelCase = num while iterations < 50: _UpperCAmelCase = sum_reverse(_UpperCAmelCase ) iterations += 1 if is_palindrome(_UpperCAmelCase ): break else: lychrel_nums.append(_UpperCAmelCase ) return len(_UpperCAmelCase ) if __name__ == "__main__": print(f"""{solution() = }""")
339
from __future__ import annotations UpperCAmelCase__ = list[list[int]] # assigning initial values to the grid UpperCAmelCase__ = [ [3, 0, 6, 5, 0, 8, 4, 0, 0], [5, 2, 0, 0, 0, 0, 0, 0, 0], [0, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] # a grid with no solution UpperCAmelCase__ = [ [5, 0, 6, 5, 0, 8, 4, 0, 3], [5, 2, 0, 0, 0, 0, 0, 0, 2], [1, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] def A ( _UpperCAmelCase : Matrix , _UpperCAmelCase : int , _UpperCAmelCase : int , _UpperCAmelCase : int ) -> bool: '''simple docstring''' for i in range(9 ): if grid[row][i] == n or grid[i][column] == n: return False for i in range(3 ): for j in range(3 ): if grid[(row - row % 3) + i][(column - column % 3) + j] == n: return False return True def A ( _UpperCAmelCase : Matrix ) -> tuple[int, int] | None: '''simple docstring''' for i in range(9 ): for j in range(9 ): if grid[i][j] == 0: return i, j return None def A ( _UpperCAmelCase : Matrix ) -> Matrix | None: '''simple docstring''' if location := find_empty_location(_UpperCAmelCase ): _UpperCAmelCase , _UpperCAmelCase = location else: # If the location is ``None``, then the grid is solved. return grid for digit in range(1 , 10 ): if is_safe(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ): _UpperCAmelCase = digit if sudoku(_UpperCAmelCase ) is not None: return grid _UpperCAmelCase = 0 return None def A ( _UpperCAmelCase : Matrix ) -> None: '''simple docstring''' for row in grid: for cell in row: print(_UpperCAmelCase , end=' ' ) print() if __name__ == "__main__": # make a copy of grid so that you can compare with the unmodified grid for example_grid in (initial_grid, no_solution): print("\nExample grid:\n" + "=" * 20) print_solution(example_grid) print("\nExample grid solution:") UpperCAmelCase__ = sudoku(example_grid) if solution is not None: print_solution(solution) else: print("Cannot find a solution.")
339
1
import datasets import faiss import numpy as np import streamlit as st import torch from elasticsearch import Elasticsearch from elia_utils import ( embed_questions_for_retrieval, make_qa_sas_model, qa_sas_generate, query_es_index, query_qa_dense_index, ) import transformers from transformers import AutoModel, AutoModelForSeqaSeqLM, AutoTokenizer UpperCAmelCase__ = "bart" UpperCAmelCase__ = True @st.cache(allow_output_mutation=_UpperCAmelCase ) def A ( ) -> Union[str, Any]: '''simple docstring''' if LOAD_DENSE_INDEX: _UpperCAmelCase = AutoTokenizer.from_pretrained('yjernite/retribert-base-uncased' ) _UpperCAmelCase = AutoModel.from_pretrained('yjernite/retribert-base-uncased' ).to('cuda:0' ) _UpperCAmelCase = qar_model.eval() else: _UpperCAmelCase , _UpperCAmelCase = (None, None) if MODEL_TYPE == "bart": _UpperCAmelCase = AutoTokenizer.from_pretrained('yjernite/bart_eli5' ) _UpperCAmelCase = AutoModelForSeqaSeqLM.from_pretrained('yjernite/bart_eli5' ).to('cuda:0' ) _UpperCAmelCase = torch.load('seq2seq_models/eli5_bart_model_blm_2.pth' ) sas_model.load_state_dict(save_dict['model'] ) _UpperCAmelCase = sas_model.eval() else: _UpperCAmelCase , _UpperCAmelCase = make_qa_sas_model( model_name='t5-small' , from_file='seq2seq_models/eli5_t5_model_1024_4.pth' , device='cuda:0' ) return (qar_tokenizer, qar_model, sas_tokenizer, sas_model) @st.cache(allow_output_mutation=_UpperCAmelCase ) def A ( ) -> Optional[int]: '''simple docstring''' if LOAD_DENSE_INDEX: _UpperCAmelCase = faiss.StandardGpuResources() _UpperCAmelCase = datasets.load_dataset(path='wiki_snippets' , name='wiki40b_en_100_0' )['train'] _UpperCAmelCase = np.memmap( 'wiki40b_passages_reps_32_l-8_h-768_b-512-512.dat' , dtype='float32' , mode='r' , shape=(wikiaab_passages.num_rows, 128) , ) _UpperCAmelCase = faiss.IndexFlatIP(128 ) _UpperCAmelCase = faiss.index_cpu_to_gpu(_UpperCAmelCase , 1 , _UpperCAmelCase ) wikiaab_gpu_index_flat.add(_UpperCAmelCase ) # TODO fix for larger GPU else: _UpperCAmelCase , _UpperCAmelCase = (None, None) _UpperCAmelCase = Elasticsearch([{'host': 'localhost', 'port': '9200'}] ) return (wikiaab_passages, wikiaab_gpu_index_flat, es_client) @st.cache(allow_output_mutation=_UpperCAmelCase ) def A ( ) -> Dict: '''simple docstring''' _UpperCAmelCase = datasets.load_dataset('eli5' , name='LFQA_reddit' ) _UpperCAmelCase = elia['train_eli5'] _UpperCAmelCase = np.memmap( 'eli5_questions_reps.dat' , dtype='float32' , mode='r' , shape=(elia_train.num_rows, 128) ) _UpperCAmelCase = faiss.IndexFlatIP(128 ) eli5_train_q_index.add(_UpperCAmelCase ) return (elia_train, eli5_train_q_index) UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = load_indexes() UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = load_models() UpperCAmelCase__ , UpperCAmelCase__ = load_train_data() def A ( _UpperCAmelCase : int , _UpperCAmelCase : Dict=10 ) -> Any: '''simple docstring''' _UpperCAmelCase = embed_questions_for_retrieval([question] , _UpperCAmelCase , _UpperCAmelCase ) _UpperCAmelCase , _UpperCAmelCase = eli5_train_q_index.search(_UpperCAmelCase , _UpperCAmelCase ) _UpperCAmelCase = [elia_train[int(_UpperCAmelCase )] for i in I[0]] return nn_examples def A ( _UpperCAmelCase : Optional[Any] , _UpperCAmelCase : str="wiki40b" , _UpperCAmelCase : Tuple="dense" , _UpperCAmelCase : str=10 ) -> Any: '''simple docstring''' if source == "none": _UpperCAmelCase , _UpperCAmelCase = (' <P> '.join(['' for _ in range(11 )] ).strip(), []) else: if method == "dense": _UpperCAmelCase , _UpperCAmelCase = query_qa_dense_index( _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) else: _UpperCAmelCase , _UpperCAmelCase = query_es_index( _UpperCAmelCase , _UpperCAmelCase , index_name='english_wiki40b_snippets_100w' , n_results=_UpperCAmelCase , ) _UpperCAmelCase = [ (res['article_title'], res['section_title'].strip(), res['score'], res['passage_text']) for res in hit_lst ] _UpperCAmelCase = 'question: {} context: {}'.format(_UpperCAmelCase , _UpperCAmelCase ) return question_doc, support_list @st.cache( hash_funcs={ torch.Tensor: (lambda _UpperCAmelCase : None), transformers.models.bart.tokenization_bart.BartTokenizer: (lambda _UpperCAmelCase : None), } ) def A ( _UpperCAmelCase : Optional[Any] , _UpperCAmelCase : str , _UpperCAmelCase : Optional[Any] , _UpperCAmelCase : List[Any]=64 , _UpperCAmelCase : int=256 , _UpperCAmelCase : Union[str, Any]=False , _UpperCAmelCase : Union[str, Any]=2 , _UpperCAmelCase : Tuple=0.95 , _UpperCAmelCase : str=0.8 ) -> Optional[int]: '''simple docstring''' with torch.no_grad(): _UpperCAmelCase = qa_sas_generate( _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , num_answers=1 , num_beams=_UpperCAmelCase , min_len=_UpperCAmelCase , max_len=_UpperCAmelCase , do_sample=_UpperCAmelCase , temp=_UpperCAmelCase , top_p=_UpperCAmelCase , top_k=_UpperCAmelCase , max_input_length=1_024 , device='cuda:0' , )[0] return (answer, support_list) st.title("Long Form Question Answering with ELI5") # Start sidebar UpperCAmelCase__ = "<img src='https://huggingface.co/front/assets/huggingface_logo.svg'>" UpperCAmelCase__ = "\n<html>\n <head>\n <style>\n .img-container {\n padding-left: 90px;\n padding-right: 90px;\n padding-top: 50px;\n padding-bottom: 50px;\n background-color: #f0f3f9;\n }\n </style>\n </head>\n <body>\n <span class=\"img-container\"> <!-- Inline parent element -->\n %s\n </span>\n </body>\n</html>\n" % ( header_html, ) st.sidebar.markdown( header_full, unsafe_allow_html=True, ) # Long Form QA with ELI5 and Wikipedia UpperCAmelCase__ = "\nThis demo presents a model trained to [provide long-form answers to open-domain questions](https://yjernite.github.io/lfqa.html).\nFirst, a document retriever fetches a set of relevant Wikipedia passages given the question from the [Wiki40b](https://research.google/pubs/pub49029/) dataset,\na pre-processed fixed snapshot of Wikipedia.\n" st.sidebar.markdown(description, unsafe_allow_html=True) UpperCAmelCase__ = [ "Answer the question", "View the retrieved document only", "View the most similar ELI5 question and answer", "Show me everything, please!", ] UpperCAmelCase__ = st.sidebar.checkbox("Demo options") if demo_options: UpperCAmelCase__ = st.sidebar.selectbox( "", action_list, index=3, ) UpperCAmelCase__ = action_list.index(action_st) UpperCAmelCase__ = st.sidebar.selectbox( "", ["Show full text of passages", "Show passage section titles"], index=0, ) UpperCAmelCase__ = show_type == "Show full text of passages" else: UpperCAmelCase__ = 3 UpperCAmelCase__ = True UpperCAmelCase__ = st.sidebar.checkbox("Retrieval options") if retrieval_options: UpperCAmelCase__ = "\n ### Information retriever options\n\n The **sparse** retriever uses ElasticSearch, while the **dense** retriever uses max-inner-product search between a question and passage embedding\n trained using the [ELI5](https://arxiv.org/abs/1907.09190) questions-answer pairs.\n The answer is then generated by sequence to sequence model which takes the question and retrieved document as input.\n " st.sidebar.markdown(retriever_info) UpperCAmelCase__ = st.sidebar.selectbox("Which Wikipedia format should the model use?", ["wiki40b", "none"]) UpperCAmelCase__ = st.sidebar.selectbox("Which Wikipedia indexer should the model use?", ["dense", "sparse", "mixed"]) else: UpperCAmelCase__ = "wiki40b" UpperCAmelCase__ = "dense" UpperCAmelCase__ = "beam" UpperCAmelCase__ = 2 UpperCAmelCase__ = 64 UpperCAmelCase__ = 256 UpperCAmelCase__ = None UpperCAmelCase__ = None UpperCAmelCase__ = st.sidebar.checkbox("Generation options") if generate_options: UpperCAmelCase__ = "\n ### Answer generation options\n\n The sequence-to-sequence model was initialized with [BART](https://huggingface.co/facebook/bart-large)\n weights and fine-tuned on the ELI5 QA pairs and retrieved documents. You can use the model for greedy decoding with\n **beam** search, or **sample** from the decoder's output probabilities.\n " st.sidebar.markdown(generate_info) UpperCAmelCase__ = st.sidebar.selectbox("Would you like to use beam search or sample an answer?", ["beam", "sampled"]) UpperCAmelCase__ = st.sidebar.slider( "Minimum generation length", min_value=8, max_value=256, value=64, step=8, format=None, key=None ) UpperCAmelCase__ = st.sidebar.slider( "Maximum generation length", min_value=64, max_value=512, value=256, step=16, format=None, key=None ) if sampled == "beam": UpperCAmelCase__ = st.sidebar.slider("Beam size", min_value=1, max_value=8, value=2, step=None, format=None, key=None) else: UpperCAmelCase__ = st.sidebar.slider( "Nucleus sampling p", min_value=0.1, max_value=1.0, value=0.95, step=0.01, format=None, key=None ) UpperCAmelCase__ = st.sidebar.slider( "Temperature", min_value=0.1, max_value=1.0, value=0.7, step=0.01, format=None, key=None ) UpperCAmelCase__ = None # start main text UpperCAmelCase__ = [ "<MY QUESTION>", "How do people make chocolate?", "Why do we get a fever when we are sick?", "How can different animals perceive different colors?", "What is natural language processing?", "What's the best way to treat a sunburn?", "What exactly are vitamins ?", "How does nuclear energy provide electricity?", "What's the difference between viruses and bacteria?", "Why are flutes classified as woodwinds when most of them are made out of metal ?", "Why do people like drinking coffee even though it tastes so bad?", "What happens when wine ages? How does it make the wine taste better?", "If an animal is an herbivore, where does it get the protein that it needs to survive if it only eats grass?", "How can we set a date to the beginning or end of an artistic period? Doesn't the change happen gradually?", "How does New Zealand have so many large bird predators?", ] UpperCAmelCase__ = st.selectbox( "What would you like to ask? ---- select <MY QUESTION> to enter a new query", questions_list, index=1, ) if question_s == "<MY QUESTION>": UpperCAmelCase__ = st.text_input("Enter your question here:", "") else: UpperCAmelCase__ = question_s if st.button("Show me!"): if action in [0, 1, 3]: if index_type == "mixed": UpperCAmelCase__ , UpperCAmelCase__ = make_support(question, source=wiki_source, method="dense", n_results=10) UpperCAmelCase__ , UpperCAmelCase__ = make_support(question, source=wiki_source, method="sparse", n_results=10) UpperCAmelCase__ = [] for res_d, res_s in zip(support_list_dense, support_list_sparse): if tuple(res_d) not in support_list: support_list += [tuple(res_d)] if tuple(res_s) not in support_list: support_list += [tuple(res_s)] UpperCAmelCase__ = support_list[:10] UpperCAmelCase__ = "<P> " + " <P> ".join([res[-1] for res in support_list]) else: UpperCAmelCase__ , UpperCAmelCase__ = make_support(question, source=wiki_source, method=index_type, n_results=10) if action in [0, 3]: UpperCAmelCase__ , UpperCAmelCase__ = answer_question( question_doc, sas_model, sas_tokenizer, min_len=min_len, max_len=int(max_len), sampling=(sampled == "sampled"), n_beams=n_beams, top_p=top_p, temp=temp, ) st.markdown("### The model generated answer is:") st.write(answer) if action in [0, 1, 3] and wiki_source != "none": st.markdown("--- \n ### The model is drawing information from the following Wikipedia passages:") for i, res in enumerate(support_list): UpperCAmelCase__ = "https://en.wikipedia.org/wiki/{}".format(res[0].replace(" ", "_")) UpperCAmelCase__ = res[1].strip() if sec_titles == "": UpperCAmelCase__ = "[{}]({})".format(res[0], wiki_url) else: UpperCAmelCase__ = sec_titles.split(" & ") UpperCAmelCase__ = " & ".join( ["[{}]({}#{})".format(sec.strip(), wiki_url, sec.strip().replace(" ", "_")) for sec in sec_list] ) st.markdown( "{0:02d} - **Article**: {1:<18} <br> _Section_: {2}".format(i + 1, res[0], sections), unsafe_allow_html=True, ) if show_passages: st.write( "> <span style=\"font-family:arial; font-size:10pt;\">" + res[-1] + "</span>", unsafe_allow_html=True ) if action in [2, 3]: UpperCAmelCase__ = find_nearest_training(question) UpperCAmelCase__ = nn_train_list[0] st.markdown( "--- \n ### The most similar question in the ELI5 training set was: \n\n {}".format(train_exple["title"]) ) UpperCAmelCase__ = [ "{}. {}".format(i + 1, " \n".join([line.strip() for line in ans.split("\n") if line.strip() != ""])) for i, (ans, sc) in enumerate(zip(train_exple["answers"]["text"], train_exple["answers"]["score"])) if i == 0 or sc > 2 ] st.markdown("##### Its answers were: \n\n {}".format("\n".join(answers_st))) UpperCAmelCase__ = "\n---\n\n**Disclaimer**\n\n*The intent of this app is to provide some (hopefully entertaining) insights into the behavior of a current LFQA system.\nEvaluating biases of such a model and ensuring factual generations are still very much open research problems.\nTherefore, until some significant progress is achieved, we caution against using the generated answers for practical purposes.*\n" st.sidebar.markdown(disclaimer, unsafe_allow_html=True)
339
import numpy as np from nltk.translate import meteor_score import datasets from datasets.config import importlib_metadata, version UpperCAmelCase__ = version.parse(importlib_metadata.version("nltk")) if NLTK_VERSION >= version.Version("3.6.4"): from nltk import word_tokenize UpperCAmelCase__ = "\\n@inproceedings{banarjee2005,\n title = {{METEOR}: An Automatic Metric for {MT} Evaluation with Improved Correlation with Human Judgments},\n author = {Banerjee, Satanjeev and Lavie, Alon},\n booktitle = {Proceedings of the {ACL} Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization},\n month = jun,\n year = {2005},\n address = {Ann Arbor, Michigan},\n publisher = {Association for Computational Linguistics},\n url = {https://www.aclweb.org/anthology/W05-0909},\n pages = {65--72},\n}\n" UpperCAmelCase__ = "\\nMETEOR, an automatic metric for machine translation evaluation\nthat is based on a generalized concept of unigram matching between the\nmachine-produced translation and human-produced reference translations.\nUnigrams can be matched based on their surface forms, stemmed forms,\nand meanings; furthermore, METEOR can be easily extended to include more\nadvanced matching strategies. Once all generalized unigram matches\nbetween the two strings have been found, METEOR computes a score for\nthis matching using a combination of unigram-precision, unigram-recall, and\na measure of fragmentation that is designed to directly capture how\nwell-ordered the matched words in the machine translation are in relation\nto the reference.\n\nMETEOR gets an R correlation value of 0.347 with human evaluation on the Arabic\ndata and 0.331 on the Chinese data. This is shown to be an improvement on\nusing simply unigram-precision, unigram-recall and their harmonic F1\ncombination.\n" UpperCAmelCase__ = "\nComputes METEOR score of translated segments against one or more references.\nArgs:\n predictions: list of predictions to score. Each prediction\n should be a string with tokens separated by spaces.\n references: list of reference for each prediction. Each\n reference should be a string with tokens separated by spaces.\n alpha: Parameter for controlling relative weights of precision and recall. default: 0.9\n beta: Parameter for controlling shape of penalty as a function of fragmentation. default: 3\n gamma: Relative weight assigned to fragmentation penalty. default: 0.5\nReturns:\n 'meteor': meteor score.\nExamples:\n\n >>> meteor = datasets.load_metric('meteor')\n >>> predictions = [\"It is a guide to action which ensures that the military always obeys the commands of the party\"]\n >>> references = [\"It is a guide to action that ensures that the military will forever heed Party commands\"]\n >>> results = meteor.compute(predictions=predictions, references=references)\n >>> print(round(results[\"meteor\"], 4))\n 0.6944\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class __lowerCAmelCase ( datasets.Metric ): def _lowerCamelCase ( self : List[Any]) -> List[Any]: """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': datasets.Value('string' , id='sequence'), 'references': datasets.Value('string' , id='sequence'), }) , codebase_urls=['https://github.com/nltk/nltk/blob/develop/nltk/translate/meteor_score.py'] , reference_urls=[ 'https://www.nltk.org/api/nltk.translate.html#module-nltk.translate.meteor_score', 'https://en.wikipedia.org/wiki/METEOR', ] , ) def _lowerCamelCase ( self : Optional[Any] , A : List[str]) -> List[Any]: """simple docstring""" import nltk nltk.download('wordnet') if NLTK_VERSION >= version.Version('3.6.5'): nltk.download('punkt') if NLTK_VERSION >= version.Version('3.6.6'): nltk.download('omw-1.4') def _lowerCamelCase ( self : Optional[Any] , A : Tuple , A : Optional[int] , A : List[Any]=0.9 , A : Optional[Any]=3 , A : Optional[int]=0.5) -> Any: """simple docstring""" if NLTK_VERSION >= version.Version('3.6.5'): _UpperCAmelCase = [ meteor_score.single_meteor_score( word_tokenize(A) , word_tokenize(A) , alpha=A , beta=A , gamma=A) for ref, pred in zip(A , A) ] else: _UpperCAmelCase = [ meteor_score.single_meteor_score(A , A , alpha=A , beta=A , gamma=A) for ref, pred in zip(A , A) ] return {"meteor": np.mean(A)}
339
1
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available UpperCAmelCase__ = { "configuration_nezha": ["NEZHA_PRETRAINED_CONFIG_ARCHIVE_MAP", "NezhaConfig"], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase__ = [ "NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST", "NezhaForNextSentencePrediction", "NezhaForMaskedLM", "NezhaForPreTraining", "NezhaForMultipleChoice", "NezhaForQuestionAnswering", "NezhaForSequenceClassification", "NezhaForTokenClassification", "NezhaModel", "NezhaPreTrainedModel", ] if TYPE_CHECKING: from .configuration_nezha import NEZHA_PRETRAINED_CONFIG_ARCHIVE_MAP, NezhaConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_nezha import ( NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST, NezhaForMaskedLM, NezhaForMultipleChoice, NezhaForNextSentencePrediction, NezhaForPreTraining, NezhaForQuestionAnswering, NezhaForSequenceClassification, NezhaForTokenClassification, NezhaModel, NezhaPreTrainedModel, ) else: import sys UpperCAmelCase__ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
339
import argparse import hashlib import os import urllib import warnings import torch from torch import nn from tqdm import tqdm from transformers import WhisperConfig, WhisperForConditionalGeneration UpperCAmelCase__ = { "tiny.en": "https://openaipublic.azureedge.net/main/whisper/models/d3dd57d32accea0b295c96e26691aa14d8822fac7d9d27d5dc00b4ca2826dd03/tiny.en.pt", "tiny": "https://openaipublic.azureedge.net/main/whisper/models/65147644a518d12f04e32d6f3b26facc3f8dd46e5390956a9424a650c0ce22b9/tiny.pt", "base.en": "https://openaipublic.azureedge.net/main/whisper/models/25a8566e1d0c1e2231d1c762132cd20e0f96a85d16145c3a00adf5d1ac670ead/base.en.pt", "base": "https://openaipublic.azureedge.net/main/whisper/models/ed3a0b6b1c0edf879ad9b11b1af5a0e6ab5db9205f891f668f8b0e6c6326e34e/base.pt", "small.en": "https://openaipublic.azureedge.net/main/whisper/models/f953ad0fd29cacd07d5a9eda5624af0f6bcf2258be67c92b79389873d91e0872/small.en.pt", "small": "https://openaipublic.azureedge.net/main/whisper/models/9ecf779972d90ba49c06d968637d720dd632c55bbf19d441fb42bf17a411e794/small.pt", "medium.en": "https://openaipublic.azureedge.net/main/whisper/models/d7440d1dc186f76616474e0ff0b3b6b879abc9d1a4926b7adfa41db2d497ab4f/medium.en.pt", "medium": "https://openaipublic.azureedge.net/main/whisper/models/345ae4da62f9b3d59415adc60127b97c714f32e89e936602e85993674d08dcb1/medium.pt", "large": "https://openaipublic.azureedge.net/main/whisper/models/e4b87e7e0bf463eb8e6956e646f1e277e901512310def2c24bf0e11bd3c28e9a/large.pt", "large-v2": "https://openaipublic.azureedge.net/main/whisper/models/81f7c96c852ee8fc832187b0132e569d6c3065a3252ed18e56effd0b6a73e524/large-v2.pt", } def A ( _UpperCAmelCase : Optional[int] ) -> str: '''simple docstring''' _UpperCAmelCase = ['layers', 'blocks'] for k in ignore_keys: state_dict.pop(_UpperCAmelCase , _UpperCAmelCase ) UpperCAmelCase__ = { "blocks": "layers", "mlp.0": "fc1", "mlp.2": "fc2", "mlp_ln": "final_layer_norm", ".attn.query": ".self_attn.q_proj", ".attn.key": ".self_attn.k_proj", ".attn.value": ".self_attn.v_proj", ".attn_ln": ".self_attn_layer_norm", ".attn.out": ".self_attn.out_proj", ".cross_attn.query": ".encoder_attn.q_proj", ".cross_attn.key": ".encoder_attn.k_proj", ".cross_attn.value": ".encoder_attn.v_proj", ".cross_attn_ln": ".encoder_attn_layer_norm", ".cross_attn.out": ".encoder_attn.out_proj", "decoder.ln.": "decoder.layer_norm.", "encoder.ln.": "encoder.layer_norm.", "token_embedding": "embed_tokens", "encoder.positional_embedding": "encoder.embed_positions.weight", "decoder.positional_embedding": "decoder.embed_positions.weight", "ln_post": "layer_norm", } def A ( _UpperCAmelCase : Dict ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = list(s_dict.keys() ) for key in keys: _UpperCAmelCase = key for k, v in WHISPER_MAPPING.items(): if k in key: _UpperCAmelCase = new_key.replace(_UpperCAmelCase , _UpperCAmelCase ) print(F"{key} -> {new_key}" ) _UpperCAmelCase = s_dict.pop(_UpperCAmelCase ) return s_dict def A ( _UpperCAmelCase : List[Any] ) -> Union[str, Any]: '''simple docstring''' _UpperCAmelCase , _UpperCAmelCase = emb.weight.shape _UpperCAmelCase = nn.Linear(_UpperCAmelCase , _UpperCAmelCase , bias=_UpperCAmelCase ) _UpperCAmelCase = emb.weight.data return lin_layer def A ( _UpperCAmelCase : str , _UpperCAmelCase : str ) -> bytes: '''simple docstring''' os.makedirs(_UpperCAmelCase , exist_ok=_UpperCAmelCase ) _UpperCAmelCase = os.path.basename(_UpperCAmelCase ) _UpperCAmelCase = url.split('/' )[-2] _UpperCAmelCase = os.path.join(_UpperCAmelCase , _UpperCAmelCase ) if os.path.exists(_UpperCAmelCase ) and not os.path.isfile(_UpperCAmelCase ): raise RuntimeError(F"{download_target} exists and is not a regular file" ) if os.path.isfile(_UpperCAmelCase ): _UpperCAmelCase = open(_UpperCAmelCase , 'rb' ).read() if hashlib.shaaaa(_UpperCAmelCase ).hexdigest() == expected_shaaaa: return model_bytes else: warnings.warn(F"{download_target} exists, but the SHA256 checksum does not match; re-downloading the file" ) with urllib.request.urlopen(_UpperCAmelCase ) as source, open(_UpperCAmelCase , 'wb' ) as output: with tqdm( total=int(source.info().get('Content-Length' ) ) , ncols=80 , unit='iB' , unit_scale=_UpperCAmelCase , unit_divisor=1_024 ) as loop: while True: _UpperCAmelCase = source.read(8_192 ) if not buffer: break output.write(_UpperCAmelCase ) loop.update(len(_UpperCAmelCase ) ) _UpperCAmelCase = open(_UpperCAmelCase , 'rb' ).read() if hashlib.shaaaa(_UpperCAmelCase ).hexdigest() != expected_shaaaa: raise RuntimeError( 'Model has been downloaded but the SHA256 checksum does not not match. Please retry loading the model.' ) return model_bytes def A ( _UpperCAmelCase : List[Any] , _UpperCAmelCase : Any ) -> Optional[int]: '''simple docstring''' if ".pt" not in checkpoint_path: _UpperCAmelCase = _download(_MODELS[checkpoint_path] ) else: _UpperCAmelCase = torch.load(_UpperCAmelCase , map_location='cpu' ) _UpperCAmelCase = original_checkpoint['dims'] _UpperCAmelCase = original_checkpoint['model_state_dict'] _UpperCAmelCase = state_dict['decoder.token_embedding.weight'] remove_ignore_keys_(_UpperCAmelCase ) rename_keys(_UpperCAmelCase ) _UpperCAmelCase = True _UpperCAmelCase = state_dict['decoder.layers.0.fc1.weight'].shape[0] _UpperCAmelCase = WhisperConfig( vocab_size=dimensions['n_vocab'] , encoder_ffn_dim=_UpperCAmelCase , decoder_ffn_dim=_UpperCAmelCase , num_mel_bins=dimensions['n_mels'] , d_model=dimensions['n_audio_state'] , max_target_positions=dimensions['n_text_ctx'] , encoder_layers=dimensions['n_audio_layer'] , encoder_attention_heads=dimensions['n_audio_head'] , decoder_layers=dimensions['n_text_layer'] , decoder_attention_heads=dimensions['n_text_state'] , max_source_positions=dimensions['n_audio_ctx'] , ) _UpperCAmelCase = WhisperForConditionalGeneration(_UpperCAmelCase ) _UpperCAmelCase , _UpperCAmelCase = model.model.load_state_dict(_UpperCAmelCase , strict=_UpperCAmelCase ) if len(_UpperCAmelCase ) > 0 and not set(_UpperCAmelCase ) <= { "encoder.embed_positions.weights", "decoder.embed_positions.weights", }: raise ValueError( 'Only `encoder.embed_positions.weights` and `decoder.embed_positions.weights` are allowed to be missing,' F" but all the following weights are missing {missing}" ) if tie_embeds: _UpperCAmelCase = make_linear_from_emb(model.model.decoder.embed_tokens ) else: _UpperCAmelCase = proj_out_weights model.save_pretrained(_UpperCAmelCase ) if __name__ == "__main__": UpperCAmelCase__ = argparse.ArgumentParser() # # Required parameters parser.add_argument("--checkpoint_path", type=str, help="Patht to the downloaded checkpoints") parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.") UpperCAmelCase__ = parser.parse_args() convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)
339
1
from math import loga def A ( _UpperCAmelCase : int ) -> int: '''simple docstring''' if a < 0: raise ValueError('Input value must be a positive integer' ) elif isinstance(_UpperCAmelCase , _UpperCAmelCase ): raise TypeError('Input value must be a \'int\' type' ) return 0 if (a == 0) else int(loga(a & -a ) ) if __name__ == "__main__": import doctest doctest.testmod()
339
from typing import List import datasets from datasets.tasks import AudioClassification from ..folder_based_builder import folder_based_builder UpperCAmelCase__ = datasets.utils.logging.get_logger(__name__) class __lowerCAmelCase ( folder_based_builder.FolderBasedBuilderConfig ): UpperCamelCase = None UpperCamelCase = None class __lowerCAmelCase ( folder_based_builder.FolderBasedBuilder ): UpperCamelCase = datasets.Audio() UpperCamelCase = '''audio''' UpperCamelCase = AudioFolderConfig UpperCamelCase = 42 # definition at the bottom of the script UpperCamelCase = AudioClassification(audio_column='''audio''' , label_column='''label''' ) UpperCAmelCase__ = [ ".aiff", ".au", ".avr", ".caf", ".flac", ".htk", ".svx", ".mat4", ".mat5", ".mpc2k", ".ogg", ".paf", ".pvf", ".raw", ".rf64", ".sd2", ".sds", ".ircam", ".voc", ".w64", ".wav", ".nist", ".wavex", ".wve", ".xi", ".mp3", ".opus", ] UpperCAmelCase__ = AUDIO_EXTENSIONS
339
1
import copy from ...configuration_utils import PretrainedConfig from ...utils import logging from ..auto import CONFIG_MAPPING UpperCAmelCase__ = logging.get_logger(__name__) UpperCAmelCase__ = { "ut/deta": "https://huggingface.co/ut/deta/resolve/main/config.json", } class __lowerCAmelCase ( A ): UpperCamelCase = '''deta''' UpperCamelCase = { '''hidden_size''': '''d_model''', '''num_attention_heads''': '''encoder_attention_heads''', } def __init__( self : Union[str, Any] , A : List[Any]=None , A : Tuple=9_00 , A : List[str]=20_48 , A : List[str]=6 , A : Any=20_48 , A : List[str]=8 , A : Tuple=6 , A : Optional[Any]=10_24 , A : Any=8 , A : Optional[Any]=0.0 , A : Tuple=True , A : Tuple="relu" , A : List[str]=2_56 , A : List[Any]=0.1 , A : Optional[int]=0.0 , A : Tuple=0.0 , A : List[Any]=0.0_2 , A : Dict=1.0 , A : str=True , A : List[Any]=False , A : Dict="sine" , A : List[str]=5 , A : str=4 , A : Optional[int]=4 , A : Any=True , A : Tuple=3_00 , A : Any=True , A : Tuple=True , A : Optional[Any]=1 , A : Dict=5 , A : int=2 , A : Optional[Any]=1 , A : Optional[int]=1 , A : Optional[Any]=5 , A : Optional[int]=2 , A : Dict=0.1 , A : Dict=0.2_5 , **A : Tuple , ) -> Optional[Any]: """simple docstring""" if backbone_config is None: logger.info('`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.') _UpperCAmelCase = CONFIG_MAPPING['resnet'](out_features=['stage2', 'stage3', 'stage4']) else: if isinstance(A , A): _UpperCAmelCase = backbone_config.pop('model_type') _UpperCAmelCase = CONFIG_MAPPING[backbone_model_type] _UpperCAmelCase = config_class.from_dict(A) _UpperCAmelCase = backbone_config _UpperCAmelCase = num_queries _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = d_model _UpperCAmelCase = encoder_ffn_dim _UpperCAmelCase = encoder_layers _UpperCAmelCase = encoder_attention_heads _UpperCAmelCase = decoder_ffn_dim _UpperCAmelCase = decoder_layers _UpperCAmelCase = decoder_attention_heads _UpperCAmelCase = dropout _UpperCAmelCase = attention_dropout _UpperCAmelCase = activation_dropout _UpperCAmelCase = activation_function _UpperCAmelCase = init_std _UpperCAmelCase = init_xavier_std _UpperCAmelCase = encoder_layerdrop _UpperCAmelCase = auxiliary_loss _UpperCAmelCase = position_embedding_type # deformable attributes _UpperCAmelCase = num_feature_levels _UpperCAmelCase = encoder_n_points _UpperCAmelCase = decoder_n_points _UpperCAmelCase = two_stage _UpperCAmelCase = two_stage_num_proposals _UpperCAmelCase = with_box_refine _UpperCAmelCase = assign_first_stage if two_stage is True and with_box_refine is False: raise ValueError('If two_stage is True, with_box_refine must be True.') # Hungarian matcher _UpperCAmelCase = class_cost _UpperCAmelCase = bbox_cost _UpperCAmelCase = giou_cost # Loss coefficients _UpperCAmelCase = mask_loss_coefficient _UpperCAmelCase = dice_loss_coefficient _UpperCAmelCase = bbox_loss_coefficient _UpperCAmelCase = giou_loss_coefficient _UpperCAmelCase = eos_coefficient _UpperCAmelCase = focal_alpha super().__init__(is_encoder_decoder=A , **A) @property def _lowerCamelCase ( self : Optional[Any]) -> int: """simple docstring""" return self.encoder_attention_heads @property def _lowerCamelCase ( self : Any) -> int: """simple docstring""" return self.d_model def _lowerCamelCase ( self : str) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = copy.deepcopy(self.__dict__) _UpperCAmelCase = self.backbone_config.to_dict() _UpperCAmelCase = self.__class__.model_type return output
339
import sys from collections import defaultdict class __lowerCAmelCase : def __init__( self : int) -> str: """simple docstring""" _UpperCAmelCase = [] def _lowerCamelCase ( self : Any , A : List[str]) -> int: """simple docstring""" return self.node_position[vertex] def _lowerCamelCase ( self : Optional[Any] , A : Optional[int] , A : str) -> List[str]: """simple docstring""" _UpperCAmelCase = pos def _lowerCamelCase ( self : Tuple , A : Tuple , A : Dict , A : List[str] , A : Optional[Any]) -> Dict: """simple docstring""" if start > size // 2 - 1: return else: if 2 * start + 2 >= size: _UpperCAmelCase = 2 * start + 1 else: if heap[2 * start + 1] < heap[2 * start + 2]: _UpperCAmelCase = 2 * start + 1 else: _UpperCAmelCase = 2 * start + 2 if heap[smallest_child] < heap[start]: _UpperCAmelCase , _UpperCAmelCase = heap[smallest_child], positions[smallest_child] _UpperCAmelCase , _UpperCAmelCase = ( heap[start], positions[start], ) _UpperCAmelCase , _UpperCAmelCase = temp, tempa _UpperCAmelCase = self.get_position(positions[smallest_child]) self.set_position( positions[smallest_child] , self.get_position(positions[start])) self.set_position(positions[start] , A) self.top_to_bottom(A , A , A , A) def _lowerCamelCase ( self : Optional[int] , A : str , A : Optional[Any] , A : Optional[int] , A : str) -> Any: """simple docstring""" _UpperCAmelCase = position[index] while index != 0: _UpperCAmelCase = int((index - 2) / 2) if index % 2 == 0 else int((index - 1) / 2) if val < heap[parent]: _UpperCAmelCase = heap[parent] _UpperCAmelCase = position[parent] self.set_position(position[parent] , A) else: _UpperCAmelCase = val _UpperCAmelCase = temp self.set_position(A , A) break _UpperCAmelCase = parent else: _UpperCAmelCase = val _UpperCAmelCase = temp self.set_position(A , 0) def _lowerCamelCase ( self : Union[str, Any] , A : Optional[int] , A : Tuple) -> str: """simple docstring""" _UpperCAmelCase = len(A) // 2 - 1 for i in range(A , -1 , -1): self.top_to_bottom(A , A , len(A) , A) def _lowerCamelCase ( self : Optional[int] , A : int , A : str) -> List[str]: """simple docstring""" _UpperCAmelCase = positions[0] _UpperCAmelCase = sys.maxsize self.top_to_bottom(A , 0 , len(A) , A) return temp def A ( _UpperCAmelCase : int ) -> Any: '''simple docstring''' _UpperCAmelCase = Heap() _UpperCAmelCase = [0] * len(_UpperCAmelCase ) _UpperCAmelCase = [-1] * len(_UpperCAmelCase ) # Neighboring Tree Vertex of selected vertex # Minimum Distance of explored vertex with neighboring vertex of partial tree # formed in graph _UpperCAmelCase = [] # Heap of Distance of vertices from their neighboring vertex _UpperCAmelCase = [] for vertex in range(len(_UpperCAmelCase ) ): distance_tv.append(sys.maxsize ) positions.append(_UpperCAmelCase ) heap.node_position.append(_UpperCAmelCase ) _UpperCAmelCase = [] _UpperCAmelCase = 1 _UpperCAmelCase = sys.maxsize for neighbor, distance in adjacency_list[0]: _UpperCAmelCase = 0 _UpperCAmelCase = distance heap.heapify(_UpperCAmelCase , _UpperCAmelCase ) for _ in range(1 , len(_UpperCAmelCase ) ): _UpperCAmelCase = heap.delete_minimum(_UpperCAmelCase , _UpperCAmelCase ) if visited[vertex] == 0: tree_edges.append((nbr_tv[vertex], vertex) ) _UpperCAmelCase = 1 for neighbor, distance in adjacency_list[vertex]: if ( visited[neighbor] == 0 and distance < distance_tv[heap.get_position(_UpperCAmelCase )] ): _UpperCAmelCase = distance heap.bottom_to_top( _UpperCAmelCase , heap.get_position(_UpperCAmelCase ) , _UpperCAmelCase , _UpperCAmelCase ) _UpperCAmelCase = vertex return tree_edges if __name__ == "__main__": # pragma: no cover # < --------- Prims Algorithm --------- > UpperCAmelCase__ = int(input("Enter number of edges: ").strip()) UpperCAmelCase__ = defaultdict(list) for _ in range(edges_number): UpperCAmelCase__ = [int(x) for x in input().strip().split()] adjacency_list[edge[0]].append([edge[1], edge[2]]) adjacency_list[edge[1]].append([edge[0], edge[2]]) print(prisms_algorithm(adjacency_list))
339
1
from graphs.minimum_spanning_tree_kruskal import kruskal def A ( ) -> Any: '''simple docstring''' _UpperCAmelCase = 9 _UpperCAmelCase = [ [0, 1, 4], [0, 7, 8], [1, 2, 8], [7, 8, 7], [7, 6, 1], [2, 8, 2], [8, 6, 6], [2, 3, 7], [2, 5, 4], [6, 5, 2], [3, 5, 14], [3, 4, 9], [5, 4, 10], [1, 7, 11], ] _UpperCAmelCase = kruskal(_UpperCAmelCase , _UpperCAmelCase ) _UpperCAmelCase = [ [7, 6, 1], [2, 8, 2], [6, 5, 2], [0, 1, 4], [2, 5, 4], [2, 3, 7], [0, 7, 8], [3, 4, 9], ] assert sorted(_UpperCAmelCase ) == sorted(_UpperCAmelCase )
339
import torch from transformers import CamembertForMaskedLM, CamembertTokenizer def A ( _UpperCAmelCase : str , _UpperCAmelCase : Any , _UpperCAmelCase : List[str] , _UpperCAmelCase : Optional[int]=5 ) -> List[Any]: '''simple docstring''' # Adapted from https://github.com/pytorch/fairseq/blob/master/fairseq/models/roberta/hub_interface.py assert masked_input.count('<mask>' ) == 1 _UpperCAmelCase = torch.tensor(tokenizer.encode(_UpperCAmelCase , add_special_tokens=_UpperCAmelCase ) ).unsqueeze(0 ) # Batch size 1 _UpperCAmelCase = model(_UpperCAmelCase )[0] # The last hidden-state is the first element of the output tuple _UpperCAmelCase = (input_ids.squeeze() == tokenizer.mask_token_id).nonzero().item() _UpperCAmelCase = logits[0, masked_index, :] _UpperCAmelCase = logits.softmax(dim=0 ) _UpperCAmelCase , _UpperCAmelCase = prob.topk(k=_UpperCAmelCase , dim=0 ) _UpperCAmelCase = ' '.join( [tokenizer.convert_ids_to_tokens(indices[i].item() ) for i in range(len(_UpperCAmelCase ) )] ) _UpperCAmelCase = tokenizer.mask_token _UpperCAmelCase = [] for index, predicted_token_bpe in enumerate(topk_predicted_token_bpe.split(' ' ) ): _UpperCAmelCase = predicted_token_bpe.replace('\u2581' , ' ' ) if " {0}".format(_UpperCAmelCase ) in masked_input: topk_filled_outputs.append( ( masked_input.replace(' {0}'.format(_UpperCAmelCase ) , _UpperCAmelCase ), values[index].item(), predicted_token, ) ) else: topk_filled_outputs.append( ( masked_input.replace(_UpperCAmelCase , _UpperCAmelCase ), values[index].item(), predicted_token, ) ) return topk_filled_outputs UpperCAmelCase__ = CamembertTokenizer.from_pretrained("camembert-base") UpperCAmelCase__ = CamembertForMaskedLM.from_pretrained("camembert-base") model.eval() UpperCAmelCase__ = "Le camembert est <mask> :)" print(fill_mask(masked_input, model, tokenizer, topk=3))
339
1
import collections import gzip import os import urllib import numpy from tensorflow.python.framework import dtypes, random_seed from tensorflow.python.platform import gfile from tensorflow.python.util.deprecation import deprecated UpperCAmelCase__ = collections.namedtuple("_Datasets", ["train", "validation", "test"]) # CVDF mirror of http://yann.lecun.com/exdb/mnist/ UpperCAmelCase__ = "https://storage.googleapis.com/cvdf-datasets/mnist/" def A ( _UpperCAmelCase : Union[str, Any] ) -> str: '''simple docstring''' _UpperCAmelCase = numpy.dtype(numpy.uintaa ).newbyteorder('>' ) return numpy.frombuffer(bytestream.read(4 ) , dtype=_UpperCAmelCase )[0] @deprecated(_UpperCAmelCase , 'Please use tf.data to implement this functionality.' ) def A ( _UpperCAmelCase : str ) -> Optional[int]: '''simple docstring''' print('Extracting' , f.name ) with gzip.GzipFile(fileobj=_UpperCAmelCase ) as bytestream: _UpperCAmelCase = _readaa(_UpperCAmelCase ) if magic != 2_051: raise ValueError( 'Invalid magic number %d in MNIST image file: %s' % (magic, f.name) ) _UpperCAmelCase = _readaa(_UpperCAmelCase ) _UpperCAmelCase = _readaa(_UpperCAmelCase ) _UpperCAmelCase = _readaa(_UpperCAmelCase ) _UpperCAmelCase = bytestream.read(rows * cols * num_images ) _UpperCAmelCase = numpy.frombuffer(_UpperCAmelCase , dtype=numpy.uinta ) _UpperCAmelCase = data.reshape(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , 1 ) return data @deprecated(_UpperCAmelCase , 'Please use tf.one_hot on tensors.' ) def A ( _UpperCAmelCase : str , _UpperCAmelCase : Optional[Any] ) -> Any: '''simple docstring''' _UpperCAmelCase = labels_dense.shape[0] _UpperCAmelCase = numpy.arange(_UpperCAmelCase ) * num_classes _UpperCAmelCase = numpy.zeros((num_labels, num_classes) ) _UpperCAmelCase = 1 return labels_one_hot @deprecated(_UpperCAmelCase , 'Please use tf.data to implement this functionality.' ) def A ( _UpperCAmelCase : int , _UpperCAmelCase : Optional[int]=False , _UpperCAmelCase : Optional[Any]=10 ) -> Optional[int]: '''simple docstring''' print('Extracting' , f.name ) with gzip.GzipFile(fileobj=_UpperCAmelCase ) as bytestream: _UpperCAmelCase = _readaa(_UpperCAmelCase ) if magic != 2_049: raise ValueError( 'Invalid magic number %d in MNIST label file: %s' % (magic, f.name) ) _UpperCAmelCase = _readaa(_UpperCAmelCase ) _UpperCAmelCase = bytestream.read(_UpperCAmelCase ) _UpperCAmelCase = numpy.frombuffer(_UpperCAmelCase , dtype=numpy.uinta ) if one_hot: return _dense_to_one_hot(_UpperCAmelCase , _UpperCAmelCase ) return labels class __lowerCAmelCase : @deprecated( A , 'Please use alternatives such as official/mnist/_DataSet.py' ' from tensorflow/models.' , ) def __init__( self : int , A : str , A : List[str] , A : Tuple=False , A : Union[str, Any]=False , A : Dict=dtypes.floataa , A : Any=True , A : Tuple=None , ) -> List[str]: """simple docstring""" _UpperCAmelCase , _UpperCAmelCase = random_seed.get_seed(A) # If op level seed is not set, use whatever graph level seed is returned numpy.random.seed(seeda if seed is None else seeda) _UpperCAmelCase = dtypes.as_dtype(A).base_dtype if dtype not in (dtypes.uinta, dtypes.floataa): raise TypeError('Invalid image dtype %r, expected uint8 or float32' % dtype) if fake_data: _UpperCAmelCase = 1_00_00 _UpperCAmelCase = one_hot else: assert ( images.shape[0] == labels.shape[0] ), F"images.shape: {images.shape} labels.shape: {labels.shape}" _UpperCAmelCase = images.shape[0] # Convert shape from [num examples, rows, columns, depth] # to [num examples, rows*columns] (assuming depth == 1) if reshape: assert images.shape[3] == 1 _UpperCAmelCase = images.reshape( images.shape[0] , images.shape[1] * images.shape[2]) if dtype == dtypes.floataa: # Convert from [0, 255] -> [0.0, 1.0]. _UpperCAmelCase = images.astype(numpy.floataa) _UpperCAmelCase = numpy.multiply(A , 1.0 / 2_5_5.0) _UpperCAmelCase = images _UpperCAmelCase = labels _UpperCAmelCase = 0 _UpperCAmelCase = 0 @property def _lowerCamelCase ( self : Optional[Any]) -> Optional[Any]: """simple docstring""" return self._images @property def _lowerCamelCase ( self : int) -> List[str]: """simple docstring""" return self._labels @property def _lowerCamelCase ( self : Any) -> List[Any]: """simple docstring""" return self._num_examples @property def _lowerCamelCase ( self : Tuple) -> Tuple: """simple docstring""" return self._epochs_completed def _lowerCamelCase ( self : List[str] , A : List[str] , A : Any=False , A : Optional[Any]=True) -> Optional[int]: """simple docstring""" if fake_data: _UpperCAmelCase = [1] * 7_84 _UpperCAmelCase = [1] + [0] * 9 if self.one_hot else 0 return ( [fake_image for _ in range(A)], [fake_label for _ in range(A)], ) _UpperCAmelCase = self._index_in_epoch # Shuffle for the first epoch if self._epochs_completed == 0 and start == 0 and shuffle: _UpperCAmelCase = numpy.arange(self._num_examples) numpy.random.shuffle(A) _UpperCAmelCase = self.images[perma] _UpperCAmelCase = self.labels[perma] # Go to the next epoch if start + batch_size > self._num_examples: # Finished epoch self._epochs_completed += 1 # Get the rest examples in this epoch _UpperCAmelCase = self._num_examples - start _UpperCAmelCase = self._images[start : self._num_examples] _UpperCAmelCase = self._labels[start : self._num_examples] # Shuffle the data if shuffle: _UpperCAmelCase = numpy.arange(self._num_examples) numpy.random.shuffle(A) _UpperCAmelCase = self.images[perm] _UpperCAmelCase = self.labels[perm] # Start next epoch _UpperCAmelCase = 0 _UpperCAmelCase = batch_size - rest_num_examples _UpperCAmelCase = self._index_in_epoch _UpperCAmelCase = self._images[start:end] _UpperCAmelCase = self._labels[start:end] return ( numpy.concatenate((images_rest_part, images_new_part) , axis=0), numpy.concatenate((labels_rest_part, labels_new_part) , axis=0), ) else: self._index_in_epoch += batch_size _UpperCAmelCase = self._index_in_epoch return self._images[start:end], self._labels[start:end] @deprecated(_UpperCAmelCase , 'Please write your own downloading logic.' ) def A ( _UpperCAmelCase : List[Any] , _UpperCAmelCase : int , _UpperCAmelCase : str ) -> Optional[Any]: '''simple docstring''' if not gfile.Exists(_UpperCAmelCase ): gfile.MakeDirs(_UpperCAmelCase ) _UpperCAmelCase = os.path.join(_UpperCAmelCase , _UpperCAmelCase ) if not gfile.Exists(_UpperCAmelCase ): urllib.request.urlretrieve(_UpperCAmelCase , _UpperCAmelCase ) # noqa: S310 with gfile.GFile(_UpperCAmelCase ) as f: _UpperCAmelCase = f.size() print('Successfully downloaded' , _UpperCAmelCase , _UpperCAmelCase , 'bytes.' ) return filepath @deprecated( _UpperCAmelCase , 'Please use alternatives such as:' ' tensorflow_datasets.load(\'mnist\')' ) def A ( _UpperCAmelCase : Union[str, Any] , _UpperCAmelCase : str=False , _UpperCAmelCase : Any=False , _UpperCAmelCase : int=dtypes.floataa , _UpperCAmelCase : List[str]=True , _UpperCAmelCase : Any=5_000 , _UpperCAmelCase : int=None , _UpperCAmelCase : List[Any]=DEFAULT_SOURCE_URL , ) -> int: '''simple docstring''' if fake_data: def fake(): return _DataSet( [] , [] , fake_data=_UpperCAmelCase , one_hot=_UpperCAmelCase , dtype=_UpperCAmelCase , seed=_UpperCAmelCase ) _UpperCAmelCase = fake() _UpperCAmelCase = fake() _UpperCAmelCase = fake() return _Datasets(train=_UpperCAmelCase , validation=_UpperCAmelCase , test=_UpperCAmelCase ) if not source_url: # empty string check _UpperCAmelCase = DEFAULT_SOURCE_URL _UpperCAmelCase = 'train-images-idx3-ubyte.gz' _UpperCAmelCase = 'train-labels-idx1-ubyte.gz' _UpperCAmelCase = 't10k-images-idx3-ubyte.gz' _UpperCAmelCase = 't10k-labels-idx1-ubyte.gz' _UpperCAmelCase = _maybe_download( _UpperCAmelCase , _UpperCAmelCase , source_url + train_images_file ) with gfile.Open(_UpperCAmelCase , 'rb' ) as f: _UpperCAmelCase = _extract_images(_UpperCAmelCase ) _UpperCAmelCase = _maybe_download( _UpperCAmelCase , _UpperCAmelCase , source_url + train_labels_file ) with gfile.Open(_UpperCAmelCase , 'rb' ) as f: _UpperCAmelCase = _extract_labels(_UpperCAmelCase , one_hot=_UpperCAmelCase ) _UpperCAmelCase = _maybe_download( _UpperCAmelCase , _UpperCAmelCase , source_url + test_images_file ) with gfile.Open(_UpperCAmelCase , 'rb' ) as f: _UpperCAmelCase = _extract_images(_UpperCAmelCase ) _UpperCAmelCase = _maybe_download( _UpperCAmelCase , _UpperCAmelCase , source_url + test_labels_file ) with gfile.Open(_UpperCAmelCase , 'rb' ) as f: _UpperCAmelCase = _extract_labels(_UpperCAmelCase , one_hot=_UpperCAmelCase ) if not 0 <= validation_size <= len(_UpperCAmelCase ): _UpperCAmelCase = ( 'Validation size should be between 0 and ' F"{len(_UpperCAmelCase )}. Received: {validation_size}." ) raise ValueError(_UpperCAmelCase ) _UpperCAmelCase = train_images[:validation_size] _UpperCAmelCase = train_labels[:validation_size] _UpperCAmelCase = train_images[validation_size:] _UpperCAmelCase = train_labels[validation_size:] _UpperCAmelCase = {'dtype': dtype, 'reshape': reshape, 'seed': seed} _UpperCAmelCase = _DataSet(_UpperCAmelCase , _UpperCAmelCase , **_UpperCAmelCase ) _UpperCAmelCase = _DataSet(_UpperCAmelCase , _UpperCAmelCase , **_UpperCAmelCase ) _UpperCAmelCase = _DataSet(_UpperCAmelCase , _UpperCAmelCase , **_UpperCAmelCase ) return _Datasets(train=_UpperCAmelCase , validation=_UpperCAmelCase , test=_UpperCAmelCase )
339
import math import unittest def A ( _UpperCAmelCase : int ) -> bool: '''simple docstring''' assert isinstance(_UpperCAmelCase , _UpperCAmelCase ) and ( number >= 0 ), "'number' must been an int and positive" if 1 < number < 4: # 2 and 3 are primes return True elif number < 2 or number % 2 == 0 or number % 3 == 0: # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes return False # All primes number are in format of 6k +/- 1 for i in range(5 , int(math.sqrt(_UpperCAmelCase ) + 1 ) , 6 ): if number % i == 0 or number % (i + 2) == 0: return False return True class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Tuple) -> Union[str, Any]: """simple docstring""" self.assertTrue(is_prime(2)) self.assertTrue(is_prime(3)) self.assertTrue(is_prime(5)) self.assertTrue(is_prime(7)) self.assertTrue(is_prime(11)) self.assertTrue(is_prime(13)) self.assertTrue(is_prime(17)) self.assertTrue(is_prime(19)) self.assertTrue(is_prime(23)) self.assertTrue(is_prime(29)) def _lowerCamelCase ( self : Optional[int]) -> Any: """simple docstring""" with self.assertRaises(A): is_prime(-19) self.assertFalse( is_prime(0) , 'Zero doesn\'t have any positive factors, primes must have exactly two.' , ) self.assertFalse( is_prime(1) , 'One only has 1 positive factor, primes must have exactly two.' , ) self.assertFalse(is_prime(2 * 2)) self.assertFalse(is_prime(2 * 3)) self.assertFalse(is_prime(3 * 3)) self.assertFalse(is_prime(3 * 5)) self.assertFalse(is_prime(3 * 5 * 7)) if __name__ == "__main__": unittest.main()
339
1
import argparse import os import jax as jnp import numpy as onp import torch import torch.nn as nn from music_spectrogram_diffusion import inference from tax import checkpoints from diffusers import DDPMScheduler, OnnxRuntimeModel, SpectrogramDiffusionPipeline from diffusers.pipelines.spectrogram_diffusion import SpectrogramContEncoder, SpectrogramNotesEncoder, TaFilmDecoder UpperCAmelCase__ = "base_with_context" def A ( _UpperCAmelCase : List[str] , _UpperCAmelCase : Union[str, Any] ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = nn.Parameter(torch.FloatTensor(weights['token_embedder']['embedding'] ) ) _UpperCAmelCase = nn.Parameter( torch.FloatTensor(weights['Embed_0']['embedding'] ) , requires_grad=_UpperCAmelCase ) for lyr_num, lyr in enumerate(model.encoders ): _UpperCAmelCase = weights[F"layers_{lyr_num}"] _UpperCAmelCase = nn.Parameter( torch.FloatTensor(ly_weight['pre_attention_layer_norm']['scale'] ) ) _UpperCAmelCase = ly_weight['attention'] _UpperCAmelCase = nn.Parameter(torch.FloatTensor(attention_weights['query']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(attention_weights['key']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(attention_weights['value']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(attention_weights['out']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(ly_weight['pre_mlp_layer_norm']['scale'] ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_0']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_1']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wo']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(weights['encoder_norm']['scale'] ) ) return model def A ( _UpperCAmelCase : Tuple , _UpperCAmelCase : int ) -> Tuple: '''simple docstring''' _UpperCAmelCase = nn.Parameter(torch.FloatTensor(weights['input_proj']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter( torch.FloatTensor(weights['Embed_0']['embedding'] ) , requires_grad=_UpperCAmelCase ) for lyr_num, lyr in enumerate(model.encoders ): _UpperCAmelCase = weights[F"layers_{lyr_num}"] _UpperCAmelCase = ly_weight['attention'] _UpperCAmelCase = nn.Parameter(torch.FloatTensor(attention_weights['query']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(attention_weights['key']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(attention_weights['value']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(attention_weights['out']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter( torch.FloatTensor(ly_weight['pre_attention_layer_norm']['scale'] ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_0']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_1']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wo']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(ly_weight['pre_mlp_layer_norm']['scale'] ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(weights['encoder_norm']['scale'] ) ) return model def A ( _UpperCAmelCase : List[str] , _UpperCAmelCase : Tuple ) -> List[Any]: '''simple docstring''' _UpperCAmelCase = nn.Parameter(torch.FloatTensor(weights['time_emb_dense0']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(weights['time_emb_dense1']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter( torch.FloatTensor(weights['Embed_0']['embedding'] ) , requires_grad=_UpperCAmelCase ) _UpperCAmelCase = nn.Parameter( torch.FloatTensor(weights['continuous_inputs_projection']['kernel'].T ) ) for lyr_num, lyr in enumerate(model.decoders ): _UpperCAmelCase = weights[F"layers_{lyr_num}"] _UpperCAmelCase = nn.Parameter( torch.FloatTensor(ly_weight['pre_self_attention_layer_norm']['scale'] ) ) _UpperCAmelCase = nn.Parameter( torch.FloatTensor(ly_weight['FiLMLayer_0']['DenseGeneral_0']['kernel'].T ) ) _UpperCAmelCase = ly_weight['self_attention'] _UpperCAmelCase = nn.Parameter(torch.FloatTensor(attention_weights['query']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(attention_weights['key']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(attention_weights['value']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(attention_weights['out']['kernel'].T ) ) _UpperCAmelCase = ly_weight['MultiHeadDotProductAttention_0'] _UpperCAmelCase = nn.Parameter(torch.FloatTensor(attention_weights['query']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(attention_weights['key']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(attention_weights['value']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(attention_weights['out']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter( torch.FloatTensor(ly_weight['pre_cross_attention_layer_norm']['scale'] ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(ly_weight['pre_mlp_layer_norm']['scale'] ) ) _UpperCAmelCase = nn.Parameter( torch.FloatTensor(ly_weight['FiLMLayer_1']['DenseGeneral_0']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_0']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_1']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wo']['kernel'].T ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(weights['decoder_norm']['scale'] ) ) _UpperCAmelCase = nn.Parameter(torch.FloatTensor(weights['spec_out_dense']['kernel'].T ) ) return model def A ( _UpperCAmelCase : Any ) -> List[str]: '''simple docstring''' _UpperCAmelCase = checkpoints.load_tax_checkpoint(args.checkpoint_path ) _UpperCAmelCase = jnp.tree_util.tree_map(onp.array , _UpperCAmelCase ) _UpperCAmelCase = [ 'from __gin__ import dynamic_registration', 'from music_spectrogram_diffusion.models.diffusion import diffusion_utils', 'diffusion_utils.ClassifierFreeGuidanceConfig.eval_condition_weight = 2.0', 'diffusion_utils.DiffusionConfig.classifier_free_guidance = @diffusion_utils.ClassifierFreeGuidanceConfig()', ] _UpperCAmelCase = os.path.join(args.checkpoint_path , '..' , 'config.gin' ) _UpperCAmelCase = inference.parse_training_gin_file(_UpperCAmelCase , _UpperCAmelCase ) _UpperCAmelCase = inference.InferenceModel(args.checkpoint_path , _UpperCAmelCase ) _UpperCAmelCase = DDPMScheduler(beta_schedule='squaredcos_cap_v2' , variance_type='fixed_large' ) _UpperCAmelCase = SpectrogramNotesEncoder( max_length=synth_model.sequence_length['inputs'] , vocab_size=synth_model.model.module.config.vocab_size , d_model=synth_model.model.module.config.emb_dim , dropout_rate=synth_model.model.module.config.dropout_rate , num_layers=synth_model.model.module.config.num_encoder_layers , num_heads=synth_model.model.module.config.num_heads , d_kv=synth_model.model.module.config.head_dim , d_ff=synth_model.model.module.config.mlp_dim , feed_forward_proj='gated-gelu' , ) _UpperCAmelCase = SpectrogramContEncoder( input_dims=synth_model.audio_codec.n_dims , targets_context_length=synth_model.sequence_length['targets_context'] , d_model=synth_model.model.module.config.emb_dim , dropout_rate=synth_model.model.module.config.dropout_rate , num_layers=synth_model.model.module.config.num_encoder_layers , num_heads=synth_model.model.module.config.num_heads , d_kv=synth_model.model.module.config.head_dim , d_ff=synth_model.model.module.config.mlp_dim , feed_forward_proj='gated-gelu' , ) _UpperCAmelCase = TaFilmDecoder( input_dims=synth_model.audio_codec.n_dims , targets_length=synth_model.sequence_length['targets_context'] , max_decoder_noise_time=synth_model.model.module.config.max_decoder_noise_time , d_model=synth_model.model.module.config.emb_dim , num_layers=synth_model.model.module.config.num_decoder_layers , num_heads=synth_model.model.module.config.num_heads , d_kv=synth_model.model.module.config.head_dim , d_ff=synth_model.model.module.config.mlp_dim , dropout_rate=synth_model.model.module.config.dropout_rate , ) _UpperCAmelCase = load_notes_encoder(ta_checkpoint['target']['token_encoder'] , _UpperCAmelCase ) _UpperCAmelCase = load_continuous_encoder(ta_checkpoint['target']['continuous_encoder'] , _UpperCAmelCase ) _UpperCAmelCase = load_decoder(ta_checkpoint['target']['decoder'] , _UpperCAmelCase ) _UpperCAmelCase = OnnxRuntimeModel.from_pretrained('kashif/soundstream_mel_decoder' ) _UpperCAmelCase = SpectrogramDiffusionPipeline( notes_encoder=_UpperCAmelCase , continuous_encoder=_UpperCAmelCase , decoder=_UpperCAmelCase , scheduler=_UpperCAmelCase , melgan=_UpperCAmelCase , ) if args.save: pipe.save_pretrained(args.output_path ) if __name__ == "__main__": UpperCAmelCase__ = argparse.ArgumentParser() parser.add_argument("--output_path", default=None, type=str, required=True, help="Path to the converted model.") parser.add_argument( "--save", default=True, type=bool, required=False, help="Whether to save the converted model or not." ) parser.add_argument( "--checkpoint_path", default=f"""{MODEL}/checkpoint_500000""", type=str, required=False, help="Path to the original jax model checkpoint.", ) UpperCAmelCase__ = parser.parse_args() main(args)
339
from typing import Dict, List from nltk.translate import gleu_score import datasets from datasets import MetricInfo UpperCAmelCase__ = "\\n@misc{wu2016googles,\n title={Google's Neural Machine Translation System: Bridging the Gap between Human and Machine Translation},\n author={Yonghui Wu and Mike Schuster and Zhifeng Chen and Quoc V. Le and Mohammad Norouzi and Wolfgang Macherey\n and Maxim Krikun and Yuan Cao and Qin Gao and Klaus Macherey and Jeff Klingner and Apurva Shah and Melvin\n Johnson and Xiaobing Liu and Łukasz Kaiser and Stephan Gouws and Yoshikiyo Kato and Taku Kudo and Hideto\n Kazawa and Keith Stevens and George Kurian and Nishant Patil and Wei Wang and Cliff Young and\n Jason Smith and Jason Riesa and Alex Rudnick and Oriol Vinyals and Greg Corrado and Macduff Hughes\n and Jeffrey Dean},\n year={2016},\n eprint={1609.08144},\n archivePrefix={arXiv},\n primaryClass={cs.CL}\n}\n" UpperCAmelCase__ = "\\nThe BLEU score has some undesirable properties when used for single\nsentences, as it was designed to be a corpus measure. We therefore\nuse a slightly different score for our RL experiments which we call\nthe 'GLEU score'. For the GLEU score, we record all sub-sequences of\n1, 2, 3 or 4 tokens in output and target sequence (n-grams). We then\ncompute a recall, which is the ratio of the number of matching n-grams\nto the number of total n-grams in the target (ground truth) sequence,\nand a precision, which is the ratio of the number of matching n-grams\nto the number of total n-grams in the generated output sequence. Then\nGLEU score is simply the minimum of recall and precision. This GLEU\nscore's range is always between 0 (no matches) and 1 (all match) and\nit is symmetrical when switching output and target. According to\nour experiments, GLEU score correlates quite well with the BLEU\nmetric on a corpus level but does not have its drawbacks for our per\nsentence reward objective.\n" UpperCAmelCase__ = "\\nComputes corpus-level Google BLEU (GLEU) score of translated segments against one or more references.\nInstead of averaging the sentence level GLEU scores (i.e. macro-average precision), Wu et al. (2016) sum up the matching\ntokens and the max of hypothesis and reference tokens for each sentence, then compute using the aggregate values.\n\nArgs:\n predictions (list of str): list of translations to score.\n Each translation should be tokenized into a list of tokens.\n references (list of list of str): list of lists of references for each translation.\n Each reference should be tokenized into a list of tokens.\n min_len (int): The minimum order of n-gram this function should extract. Defaults to 1.\n max_len (int): The maximum order of n-gram this function should extract. Defaults to 4.\n\nReturns:\n 'google_bleu': google_bleu score\n\nExamples:\n Example 1:\n >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'always',\n ... 'disobeys', 'the', 'commands', 'of', 'the', 'cat']\n >>> ref1a = ['It', 'is', 'the', 'guiding', 'principle', 'which',\n ... 'guarantees', 'the', 'rubber', 'duck', 'forces', 'never',\n ... 'being', 'under', 'the', 'command', 'of', 'the', 'cat']\n\n >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was',\n ... 'interested', 'in', 'world', 'history']\n >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history',\n ... 'because', 'he', 'read', 'the', 'book']\n\n >>> list_of_references = [[ref1a], [ref2a]]\n >>> hypotheses = [hyp1, hyp2]\n >>> google_bleu = datasets.load_metric(\"google_bleu\")\n >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references)\n >>> print(round(results[\"google_bleu\"], 2))\n 0.44\n\n Example 2:\n >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'always',\n ... 'disobeys', 'the', 'commands', 'of', 'the', 'cat']\n >>> ref1a = ['It', 'is', 'the', 'guiding', 'principle', 'which',\n ... 'guarantees', 'the', 'rubber', 'duck', 'forces', 'never',\n ... 'being', 'under', 'the', 'command', 'of', 'the', 'cat']\n >>> ref1b = ['It', 'is', 'a', 'guide', 'to', 'action', 'that',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'will', 'never',\n ... 'heed', 'the', 'cat', 'commands']\n >>> ref1c = ['It', 'is', 'the', 'practical', 'guide', 'for', 'the',\n ... 'rubber', 'duck', 'army', 'never', 'to', 'heed', 'the', 'directions',\n ... 'of', 'the', 'cat']\n\n >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was',\n ... 'interested', 'in', 'world', 'history']\n >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history',\n ... 'because', 'he', 'read', 'the', 'book']\n\n >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]\n >>> hypotheses = [hyp1, hyp2]\n >>> google_bleu = datasets.load_metric(\"google_bleu\")\n >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references)\n >>> print(round(results[\"google_bleu\"], 2))\n 0.61\n\n Example 3:\n >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'always',\n ... 'disobeys', 'the', 'commands', 'of', 'the', 'cat']\n >>> ref1a = ['It', 'is', 'the', 'guiding', 'principle', 'which',\n ... 'guarantees', 'the', 'rubber', 'duck', 'forces', 'never',\n ... 'being', 'under', 'the', 'command', 'of', 'the', 'cat']\n >>> ref1b = ['It', 'is', 'a', 'guide', 'to', 'action', 'that',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'will', 'never',\n ... 'heed', 'the', 'cat', 'commands']\n >>> ref1c = ['It', 'is', 'the', 'practical', 'guide', 'for', 'the',\n ... 'rubber', 'duck', 'army', 'never', 'to', 'heed', 'the', 'directions',\n ... 'of', 'the', 'cat']\n\n >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was',\n ... 'interested', 'in', 'world', 'history']\n >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history',\n ... 'because', 'he', 'read', 'the', 'book']\n\n >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]\n >>> hypotheses = [hyp1, hyp2]\n >>> google_bleu = datasets.load_metric(\"google_bleu\")\n >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references, min_len=2)\n >>> print(round(results[\"google_bleu\"], 2))\n 0.53\n\n Example 4:\n >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'always',\n ... 'disobeys', 'the', 'commands', 'of', 'the', 'cat']\n >>> ref1a = ['It', 'is', 'the', 'guiding', 'principle', 'which',\n ... 'guarantees', 'the', 'rubber', 'duck', 'forces', 'never',\n ... 'being', 'under', 'the', 'command', 'of', 'the', 'cat']\n >>> ref1b = ['It', 'is', 'a', 'guide', 'to', 'action', 'that',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'will', 'never',\n ... 'heed', 'the', 'cat', 'commands']\n >>> ref1c = ['It', 'is', 'the', 'practical', 'guide', 'for', 'the',\n ... 'rubber', 'duck', 'army', 'never', 'to', 'heed', 'the', 'directions',\n ... 'of', 'the', 'cat']\n\n >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was',\n ... 'interested', 'in', 'world', 'history']\n >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history',\n ... 'because', 'he', 'read', 'the', 'book']\n\n >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]\n >>> hypotheses = [hyp1, hyp2]\n >>> google_bleu = datasets.load_metric(\"google_bleu\")\n >>> results = google_bleu.compute(predictions=hypotheses,references=list_of_references, min_len=2, max_len=6)\n >>> print(round(results[\"google_bleu\"], 2))\n 0.4\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class __lowerCAmelCase ( datasets.Metric ): def _lowerCamelCase ( self : str) -> MetricInfo: """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': datasets.Sequence(datasets.Value('string' , id='token') , id='sequence'), 'references': datasets.Sequence( datasets.Sequence(datasets.Value('string' , id='token') , id='sequence') , id='references'), }) , ) def _lowerCamelCase ( self : Union[str, Any] , A : List[List[List[str]]] , A : List[List[str]] , A : int = 1 , A : int = 4 , ) -> Dict[str, float]: """simple docstring""" return { "google_bleu": gleu_score.corpus_gleu( list_of_references=A , hypotheses=A , min_len=A , max_len=A) }
339
1
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available UpperCAmelCase__ = {} try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase__ = ["MLukeTokenizer"] if TYPE_CHECKING: try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_mluke import MLukeTokenizer else: import sys UpperCAmelCase__ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
339
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_sentencepiece_available, is_tf_available, is_tokenizers_available, is_torch_available, ) if is_sentencepiece_available(): from ..ta.tokenization_ta import TaTokenizer else: from ...utils.dummy_sentencepiece_objects import TaTokenizer UpperCAmelCase__ = TaTokenizer if is_tokenizers_available(): from ..ta.tokenization_ta_fast import TaTokenizerFast else: from ...utils.dummy_tokenizers_objects import TaTokenizerFast UpperCAmelCase__ = TaTokenizerFast UpperCAmelCase__ = {"configuration_mt5": ["MT5Config", "MT5OnnxConfig"]} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase__ = [ "MT5EncoderModel", "MT5ForConditionalGeneration", "MT5ForQuestionAnswering", "MT5Model", "MT5PreTrainedModel", "MT5Stack", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase__ = ["TFMT5EncoderModel", "TFMT5ForConditionalGeneration", "TFMT5Model"] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase__ = ["FlaxMT5EncoderModel", "FlaxMT5ForConditionalGeneration", "FlaxMT5Model"] if TYPE_CHECKING: from .configuration_mta import MTaConfig, MTaOnnxConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_mta import ( MTaEncoderModel, MTaForConditionalGeneration, MTaForQuestionAnswering, MTaModel, MTaPreTrainedModel, MTaStack, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_mta import TFMTaEncoderModel, TFMTaForConditionalGeneration, TFMTaModel try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_mta import FlaxMTaEncoderModel, FlaxMTaForConditionalGeneration, FlaxMTaModel else: import sys UpperCAmelCase__ = _LazyModule( __name__, globals()["__file__"], _import_structure, extra_objects={"MT5Tokenizer": MTaTokenizer, "MT5TokenizerFast": MTaTokenizerFast}, module_spec=__spec__, )
339
1
import math from collections import defaultdict from typing import List, Optional, Tuple, Union import numpy as np import torch from ..configuration_utils import ConfigMixin, register_to_config from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin, SchedulerOutput def A ( _UpperCAmelCase : List[Any] , _UpperCAmelCase : Optional[Any]=0.999 , _UpperCAmelCase : Tuple="cosine" , ) -> int: '''simple docstring''' if alpha_transform_type == "cosine": def alpha_bar_fn(_UpperCAmelCase : Union[str, Any] ): return math.cos((t + 0.008) / 1.008 * math.pi / 2 ) ** 2 elif alpha_transform_type == "exp": def alpha_bar_fn(_UpperCAmelCase : List[Any] ): return math.exp(t * -12.0 ) else: raise ValueError(F"Unsupported alpha_tranform_type: {alpha_transform_type}" ) _UpperCAmelCase = [] for i in range(_UpperCAmelCase ): _UpperCAmelCase = i / num_diffusion_timesteps _UpperCAmelCase = (i + 1) / num_diffusion_timesteps betas.append(min(1 - alpha_bar_fn(_UpperCAmelCase ) / alpha_bar_fn(_UpperCAmelCase ) , _UpperCAmelCase ) ) return torch.tensor(_UpperCAmelCase , dtype=torch.floataa ) class __lowerCAmelCase ( A , A ): UpperCamelCase = [e.name for e in KarrasDiffusionSchedulers] UpperCamelCase = 2 @register_to_config def __init__( self : Union[str, Any] , A : int = 10_00 , A : float = 0.0_0_0_8_5 , A : float = 0.0_1_2 , A : str = "linear" , A : Optional[Union[np.ndarray, List[float]]] = None , A : str = "epsilon" , A : Optional[bool] = False , A : Optional[bool] = False , A : float = 1.0 , A : str = "linspace" , A : int = 0 , ) -> Optional[int]: """simple docstring""" if trained_betas is not None: _UpperCAmelCase = torch.tensor(A , dtype=torch.floataa) elif beta_schedule == "linear": _UpperCAmelCase = torch.linspace(A , A , A , dtype=torch.floataa) elif beta_schedule == "scaled_linear": # this schedule is very specific to the latent diffusion model. _UpperCAmelCase = ( torch.linspace(beta_start**0.5 , beta_end**0.5 , A , dtype=torch.floataa) ** 2 ) elif beta_schedule == "squaredcos_cap_v2": # Glide cosine schedule _UpperCAmelCase = betas_for_alpha_bar(A , alpha_transform_type='cosine') elif beta_schedule == "exp": _UpperCAmelCase = betas_for_alpha_bar(A , alpha_transform_type='exp') else: raise NotImplementedError(F"{beta_schedule} does is not implemented for {self.__class__}") _UpperCAmelCase = 1.0 - self.betas _UpperCAmelCase = torch.cumprod(self.alphas , dim=0) # set all values self.set_timesteps(A , A , A) _UpperCAmelCase = use_karras_sigmas def _lowerCamelCase ( self : Optional[int] , A : Dict , A : Optional[Any]=None) -> Optional[int]: """simple docstring""" if schedule_timesteps is None: _UpperCAmelCase = self.timesteps _UpperCAmelCase = (schedule_timesteps == timestep).nonzero() # The sigma index that is taken for the **very** first `step` # is always the second index (or the last index if there is only 1) # This way we can ensure we don't accidentally skip a sigma in # case we start in the middle of the denoising schedule (e.g. for image-to-image) if len(self._index_counter) == 0: _UpperCAmelCase = 1 if len(A) > 1 else 0 else: _UpperCAmelCase = timestep.cpu().item() if torch.is_tensor(A) else timestep _UpperCAmelCase = self._index_counter[timestep_int] return indices[pos].item() @property def _lowerCamelCase ( self : Any) -> int: """simple docstring""" if self.config.timestep_spacing in ["linspace", "trailing"]: return self.sigmas.max() return (self.sigmas.max() ** 2 + 1) ** 0.5 def _lowerCamelCase ( self : Optional[Any] , A : torch.FloatTensor , A : Union[float, torch.FloatTensor] , ) -> torch.FloatTensor: """simple docstring""" _UpperCAmelCase = self.index_for_timestep(A) _UpperCAmelCase = self.sigmas[step_index] _UpperCAmelCase = sample / ((sigma**2 + 1) ** 0.5) return sample def _lowerCamelCase ( self : List[str] , A : int , A : Union[str, torch.device] = None , A : Optional[int] = None , ) -> str: """simple docstring""" _UpperCAmelCase = num_inference_steps _UpperCAmelCase = num_train_timesteps or self.config.num_train_timesteps # "linspace", "leading", "trailing" corresponds to annotation of Table 2. of https://arxiv.org/abs/2305.08891 if self.config.timestep_spacing == "linspace": _UpperCAmelCase = np.linspace(0 , num_train_timesteps - 1 , A , dtype=A)[::-1].copy() elif self.config.timestep_spacing == "leading": _UpperCAmelCase = num_train_timesteps // self.num_inference_steps # creates integer timesteps by multiplying by ratio # casting to int to avoid issues when num_inference_step is power of 3 _UpperCAmelCase = (np.arange(0 , A) * step_ratio).round()[::-1].copy().astype(A) timesteps += self.config.steps_offset elif self.config.timestep_spacing == "trailing": _UpperCAmelCase = num_train_timesteps / self.num_inference_steps # creates integer timesteps by multiplying by ratio # casting to int to avoid issues when num_inference_step is power of 3 _UpperCAmelCase = (np.arange(A , 0 , -step_ratio)).round().copy().astype(A) timesteps -= 1 else: raise ValueError( F"{self.config.timestep_spacing} is not supported. Please make sure to choose one of 'linspace', 'leading' or 'trailing'.") _UpperCAmelCase = np.array(((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5) _UpperCAmelCase = np.log(A) _UpperCAmelCase = np.interp(A , np.arange(0 , len(A)) , A) if self.config.use_karras_sigmas: _UpperCAmelCase = self._convert_to_karras(in_sigmas=A , num_inference_steps=self.num_inference_steps) _UpperCAmelCase = np.array([self._sigma_to_t(A , A) for sigma in sigmas]) _UpperCAmelCase = np.concatenate([sigmas, [0.0]]).astype(np.floataa) _UpperCAmelCase = torch.from_numpy(A).to(device=A) _UpperCAmelCase = torch.cat([sigmas[:1], sigmas[1:-1].repeat_interleave(2), sigmas[-1:]]) _UpperCAmelCase = torch.from_numpy(A) _UpperCAmelCase = torch.cat([timesteps[:1], timesteps[1:].repeat_interleave(2)]) if str(A).startswith('mps'): # mps does not support float64 _UpperCAmelCase = timesteps.to(A , dtype=torch.floataa) else: _UpperCAmelCase = timesteps.to(device=A) # empty dt and derivative _UpperCAmelCase = None _UpperCAmelCase = None # for exp beta schedules, such as the one for `pipeline_shap_e.py` # we need an index counter _UpperCAmelCase = defaultdict(A) def _lowerCamelCase ( self : List[Any] , A : List[str] , A : List[str]) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = np.log(A) # get distribution _UpperCAmelCase = log_sigma - log_sigmas[:, np.newaxis] # get sigmas range _UpperCAmelCase = np.cumsum((dists >= 0) , axis=0).argmax(axis=0).clip(max=log_sigmas.shape[0] - 2) _UpperCAmelCase = low_idx + 1 _UpperCAmelCase = log_sigmas[low_idx] _UpperCAmelCase = log_sigmas[high_idx] # interpolate sigmas _UpperCAmelCase = (low - log_sigma) / (low - high) _UpperCAmelCase = np.clip(A , 0 , 1) # transform interpolation to time range _UpperCAmelCase = (1 - w) * low_idx + w * high_idx _UpperCAmelCase = t.reshape(sigma.shape) return t def _lowerCamelCase ( self : Union[str, Any] , A : torch.FloatTensor , A : int) -> torch.FloatTensor: """simple docstring""" _UpperCAmelCase = in_sigmas[-1].item() _UpperCAmelCase = in_sigmas[0].item() _UpperCAmelCase = 7.0 # 7.0 is the value used in the paper _UpperCAmelCase = np.linspace(0 , 1 , A) _UpperCAmelCase = sigma_min ** (1 / rho) _UpperCAmelCase = sigma_max ** (1 / rho) _UpperCAmelCase = (max_inv_rho + ramp * (min_inv_rho - max_inv_rho)) ** rho return sigmas @property def _lowerCamelCase ( self : int) -> List[Any]: """simple docstring""" return self.dt is None def _lowerCamelCase ( self : Optional[Any] , A : Union[torch.FloatTensor, np.ndarray] , A : Union[float, torch.FloatTensor] , A : Union[torch.FloatTensor, np.ndarray] , A : bool = True , ) -> Union[SchedulerOutput, Tuple]: """simple docstring""" _UpperCAmelCase = self.index_for_timestep(A) # advance index counter by 1 _UpperCAmelCase = timestep.cpu().item() if torch.is_tensor(A) else timestep self._index_counter[timestep_int] += 1 if self.state_in_first_order: _UpperCAmelCase = self.sigmas[step_index] _UpperCAmelCase = self.sigmas[step_index + 1] else: # 2nd order / Heun's method _UpperCAmelCase = self.sigmas[step_index - 1] _UpperCAmelCase = self.sigmas[step_index] # currently only gamma=0 is supported. This usually works best anyways. # We can support gamma in the future but then need to scale the timestep before # passing it to the model which requires a change in API _UpperCAmelCase = 0 _UpperCAmelCase = sigma * (gamma + 1) # Note: sigma_hat == sigma for now # 1. compute predicted original sample (x_0) from sigma-scaled predicted noise if self.config.prediction_type == "epsilon": _UpperCAmelCase = sigma_hat if self.state_in_first_order else sigma_next _UpperCAmelCase = sample - sigma_input * model_output elif self.config.prediction_type == "v_prediction": _UpperCAmelCase = sigma_hat if self.state_in_first_order else sigma_next _UpperCAmelCase = model_output * (-sigma_input / (sigma_input**2 + 1) ** 0.5) + ( sample / (sigma_input**2 + 1) ) elif self.config.prediction_type == "sample": _UpperCAmelCase = model_output else: raise ValueError( F"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, or `v_prediction`") if self.config.clip_sample: _UpperCAmelCase = pred_original_sample.clamp( -self.config.clip_sample_range , self.config.clip_sample_range) if self.state_in_first_order: # 2. Convert to an ODE derivative for 1st order _UpperCAmelCase = (sample - pred_original_sample) / sigma_hat # 3. delta timestep _UpperCAmelCase = sigma_next - sigma_hat # store for 2nd order step _UpperCAmelCase = derivative _UpperCAmelCase = dt _UpperCAmelCase = sample else: # 2. 2nd order / Heun's method _UpperCAmelCase = (sample - pred_original_sample) / sigma_next _UpperCAmelCase = (self.prev_derivative + derivative) / 2 # 3. take prev timestep & sample _UpperCAmelCase = self.dt _UpperCAmelCase = self.sample # free dt and derivative # Note, this puts the scheduler in "first order mode" _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = sample + derivative * dt if not return_dict: return (prev_sample,) return SchedulerOutput(prev_sample=A) def _lowerCamelCase ( self : str , A : torch.FloatTensor , A : torch.FloatTensor , A : torch.FloatTensor , ) -> torch.FloatTensor: """simple docstring""" _UpperCAmelCase = self.sigmas.to(device=original_samples.device , dtype=original_samples.dtype) if original_samples.device.type == "mps" and torch.is_floating_point(A): # mps does not support float64 _UpperCAmelCase = self.timesteps.to(original_samples.device , dtype=torch.floataa) _UpperCAmelCase = timesteps.to(original_samples.device , dtype=torch.floataa) else: _UpperCAmelCase = self.timesteps.to(original_samples.device) _UpperCAmelCase = timesteps.to(original_samples.device) _UpperCAmelCase = [self.index_for_timestep(A , A) for t in timesteps] _UpperCAmelCase = sigmas[step_indices].flatten() while len(sigma.shape) < len(original_samples.shape): _UpperCAmelCase = sigma.unsqueeze(-1) _UpperCAmelCase = original_samples + noise * sigma return noisy_samples def __len__( self : Tuple) -> int: """simple docstring""" return self.config.num_train_timesteps
339
from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCAmelCase__ = logging.get_logger(__name__) UpperCAmelCase__ = { "s-JoL/Open-Llama-V1": "https://huggingface.co/s-JoL/Open-Llama-V1/blob/main/config.json", } class __lowerCAmelCase ( A ): UpperCamelCase = '''open-llama''' def __init__( self : str , A : List[Any]=10_00_00 , A : Tuple=40_96 , A : Tuple=1_10_08 , A : List[str]=32 , A : Tuple=32 , A : Optional[Any]="silu" , A : int=20_48 , A : Optional[Any]=0.0_2 , A : Dict=1E-6 , A : Optional[Any]=True , A : List[Any]=0 , A : Dict=1 , A : int=2 , A : Dict=False , A : Optional[int]=True , A : List[Any]=0.1 , A : str=0.1 , A : Dict=True , A : Optional[Any]=True , A : Dict=None , **A : Union[str, Any] , ) -> Dict: """simple docstring""" _UpperCAmelCase = vocab_size _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = hidden_size _UpperCAmelCase = intermediate_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = hidden_act _UpperCAmelCase = initializer_range _UpperCAmelCase = rms_norm_eps _UpperCAmelCase = use_cache _UpperCAmelCase = kwargs.pop( 'use_memorry_efficient_attention' , A) _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_dropout_prob _UpperCAmelCase = use_stable_embedding _UpperCAmelCase = shared_input_output_embedding _UpperCAmelCase = rope_scaling self._rope_scaling_validation() super().__init__( pad_token_id=A , bos_token_id=A , eos_token_id=A , tie_word_embeddings=A , **A , ) def _lowerCamelCase ( self : List[str]) -> Union[str, Any]: """simple docstring""" if self.rope_scaling is None: return if not isinstance(self.rope_scaling , A) or len(self.rope_scaling) != 2: raise ValueError( '`rope_scaling` must be a dictionary with with two fields, `name` and `factor`, ' F"got {self.rope_scaling}") _UpperCAmelCase = self.rope_scaling.get('type' , A) _UpperCAmelCase = self.rope_scaling.get('factor' , A) if rope_scaling_type is None or rope_scaling_type not in ["linear", "dynamic"]: raise ValueError( F"`rope_scaling`'s name field must be one of ['linear', 'dynamic'], got {rope_scaling_type}") if rope_scaling_factor is None or not isinstance(A , A) or rope_scaling_factor <= 1.0: raise ValueError(F"`rope_scaling`'s factor field must be an float > 1, got {rope_scaling_factor}")
339
1
import torch from transformers import CamembertForMaskedLM, CamembertTokenizer def A ( _UpperCAmelCase : str , _UpperCAmelCase : Any , _UpperCAmelCase : List[str] , _UpperCAmelCase : Optional[int]=5 ) -> List[Any]: '''simple docstring''' # Adapted from https://github.com/pytorch/fairseq/blob/master/fairseq/models/roberta/hub_interface.py assert masked_input.count('<mask>' ) == 1 _UpperCAmelCase = torch.tensor(tokenizer.encode(_UpperCAmelCase , add_special_tokens=_UpperCAmelCase ) ).unsqueeze(0 ) # Batch size 1 _UpperCAmelCase = model(_UpperCAmelCase )[0] # The last hidden-state is the first element of the output tuple _UpperCAmelCase = (input_ids.squeeze() == tokenizer.mask_token_id).nonzero().item() _UpperCAmelCase = logits[0, masked_index, :] _UpperCAmelCase = logits.softmax(dim=0 ) _UpperCAmelCase , _UpperCAmelCase = prob.topk(k=_UpperCAmelCase , dim=0 ) _UpperCAmelCase = ' '.join( [tokenizer.convert_ids_to_tokens(indices[i].item() ) for i in range(len(_UpperCAmelCase ) )] ) _UpperCAmelCase = tokenizer.mask_token _UpperCAmelCase = [] for index, predicted_token_bpe in enumerate(topk_predicted_token_bpe.split(' ' ) ): _UpperCAmelCase = predicted_token_bpe.replace('\u2581' , ' ' ) if " {0}".format(_UpperCAmelCase ) in masked_input: topk_filled_outputs.append( ( masked_input.replace(' {0}'.format(_UpperCAmelCase ) , _UpperCAmelCase ), values[index].item(), predicted_token, ) ) else: topk_filled_outputs.append( ( masked_input.replace(_UpperCAmelCase , _UpperCAmelCase ), values[index].item(), predicted_token, ) ) return topk_filled_outputs UpperCAmelCase__ = CamembertTokenizer.from_pretrained("camembert-base") UpperCAmelCase__ = CamembertForMaskedLM.from_pretrained("camembert-base") model.eval() UpperCAmelCase__ = "Le camembert est <mask> :)" print(fill_mask(masked_input, model, tokenizer, topk=3))
339
def A ( _UpperCAmelCase : str ) -> bool: '''simple docstring''' return credit_card_number.startswith(('34', '35', '37', '4', '5', '6') ) def A ( _UpperCAmelCase : str ) -> bool: '''simple docstring''' _UpperCAmelCase = credit_card_number _UpperCAmelCase = 0 _UpperCAmelCase = len(_UpperCAmelCase ) - 2 for i in range(_UpperCAmelCase , -1 , -2 ): # double the value of every second digit _UpperCAmelCase = int(cc_number[i] ) digit *= 2 # If doubling of a number results in a two digit number # i.e greater than 9(e.g., 6 × 2 = 12), # then add the digits of the product (e.g., 12: 1 + 2 = 3, 15: 1 + 5 = 6), # to get a single digit number. if digit > 9: digit %= 10 digit += 1 _UpperCAmelCase = cc_number[:i] + str(_UpperCAmelCase ) + cc_number[i + 1 :] total += digit # Sum up the remaining digits for i in range(len(_UpperCAmelCase ) - 1 , -1 , -2 ): total += int(cc_number[i] ) return total % 10 == 0 def A ( _UpperCAmelCase : str ) -> bool: '''simple docstring''' _UpperCAmelCase = F"{credit_card_number} is an invalid credit card number because" if not credit_card_number.isdigit(): print(F"{error_message} it has nonnumerical characters." ) return False if not 13 <= len(_UpperCAmelCase ) <= 16: print(F"{error_message} of its length." ) return False if not validate_initial_digits(_UpperCAmelCase ): print(F"{error_message} of its first two digits." ) return False if not luhn_validation(_UpperCAmelCase ): print(F"{error_message} it fails the Luhn check." ) return False print(F"{credit_card_number} is a valid credit card number." ) return True if __name__ == "__main__": import doctest doctest.testmod() validate_credit_card_number("4111111111111111") validate_credit_card_number("32323")
339
1
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__ = { "distilbert": (DistilBertConfig, DistilBertForMaskedLM, DistilBertTokenizer), "roberta": (RobertaConfig, RobertaForMaskedLM, RobertaTokenizer), "bert": (BertConfig, BertForMaskedLM, BertTokenizer), "gpt2": (GPTaConfig, GPTaLMHeadModel, GPTaTokenizer), } def A ( _UpperCAmelCase : Optional[Any] ) -> Tuple: '''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 A ( _UpperCAmelCase : Dict , _UpperCAmelCase : Union[str, Any] ) -> str: '''simple docstring''' if args.student_type == "roberta": _UpperCAmelCase = False elif args.student_type == "gpt2": _UpperCAmelCase = False def A ( _UpperCAmelCase : Optional[Any] , _UpperCAmelCase : int ) -> str: '''simple docstring''' if args.student_type == "roberta": _UpperCAmelCase = False def A ( ) -> Dict: '''simple docstring''' _UpperCAmelCase = 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=_UpperCAmelCase , required=_UpperCAmelCase , help='The output directory (log, checkpoints, parameters, etc.)' ) parser.add_argument( '--data_file' , type=_UpperCAmelCase , required=_UpperCAmelCase , help='The binarized file (tokenized + tokens_to_ids) and grouped by sequence.' , ) parser.add_argument( '--student_type' , type=_UpperCAmelCase , choices=['distilbert', 'roberta', 'gpt2'] , required=_UpperCAmelCase , help='The student type (DistilBERT, RoBERTa).' , ) parser.add_argument('--student_config' , type=_UpperCAmelCase , required=_UpperCAmelCase , help='Path to the student configuration.' ) parser.add_argument( '--student_pretrained_weights' , default=_UpperCAmelCase , type=_UpperCAmelCase , help='Load student initialization checkpoint.' ) parser.add_argument( '--teacher_type' , choices=['bert', 'roberta', 'gpt2'] , required=_UpperCAmelCase , help='Teacher type (BERT, RoBERTa).' ) parser.add_argument('--teacher_name' , type=_UpperCAmelCase , required=_UpperCAmelCase , help='The teacher model.' ) parser.add_argument('--temperature' , default=2.0 , type=_UpperCAmelCase , help='Temperature for the softmax temperature.' ) parser.add_argument( '--alpha_ce' , default=0.5 , type=_UpperCAmelCase , help='Linear weight for the distillation loss. Must be >=0.' ) parser.add_argument( '--alpha_mlm' , default=0.0 , type=_UpperCAmelCase , 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=_UpperCAmelCase , help='Linear weight for the CLM loss. Must be >=0.' ) parser.add_argument('--alpha_mse' , default=0.0 , type=_UpperCAmelCase , help='Linear weight of the MSE loss. Must be >=0.' ) parser.add_argument( '--alpha_cos' , default=0.0 , type=_UpperCAmelCase , 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=_UpperCAmelCase , help='Proportion of tokens for which we need to make a prediction.' , ) parser.add_argument('--word_mask' , default=0.8 , type=_UpperCAmelCase , help='Proportion of tokens to mask out.' ) parser.add_argument('--word_keep' , default=0.1 , type=_UpperCAmelCase , help='Proportion of tokens to keep.' ) parser.add_argument('--word_rand' , default=0.1 , type=_UpperCAmelCase , help='Proportion of tokens to randomly replace.' ) parser.add_argument( '--mlm_smoothing' , default=0.7 , type=_UpperCAmelCase , help='Smoothing parameter to emphasize more rare tokens (see XLM, similar to word2vec).' , ) parser.add_argument('--token_counts' , type=_UpperCAmelCase , 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=_UpperCAmelCase , default=3 , help='Number of pass on the whole dataset.' ) parser.add_argument('--batch_size' , type=_UpperCAmelCase , 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=_UpperCAmelCase , default=50 , help='Gradient accumulation for larger training batches.' , ) parser.add_argument('--warmup_prop' , default=0.05 , type=_UpperCAmelCase , help='Linear warmup proportion.' ) parser.add_argument('--weight_decay' , default=0.0 , type=_UpperCAmelCase , help='Weight decay if we apply some.' ) parser.add_argument('--learning_rate' , default=5E-4 , type=_UpperCAmelCase , help='The initial learning rate for Adam.' ) parser.add_argument('--adam_epsilon' , default=1E-6 , type=_UpperCAmelCase , help='Epsilon for Adam optimizer.' ) parser.add_argument('--max_grad_norm' , default=5.0 , type=_UpperCAmelCase , help='Max gradient norm.' ) parser.add_argument('--initializer_range' , default=0.02 , type=_UpperCAmelCase , 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=_UpperCAmelCase , 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=_UpperCAmelCase , default=1 , help='Number of GPUs in the node.' ) parser.add_argument('--local_rank' , type=_UpperCAmelCase , default=-1 , help='Distributed training - Local rank' ) parser.add_argument('--seed' , type=_UpperCAmelCase , default=56 , help='Random seed' ) parser.add_argument('--log_interval' , type=_UpperCAmelCase , default=500 , help='Tensorboard logging interval.' ) parser.add_argument('--checkpoint_interval' , type=_UpperCAmelCase , default=4_000 , help='Checkpoint interval.' ) _UpperCAmelCase = parser.parse_args() sanity_checks(_UpperCAmelCase ) # ARGS # init_gpu_params(_UpperCAmelCase ) set_seed(_UpperCAmelCase ) 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(_UpperCAmelCase ) , _UpperCAmelCase , indent=4 ) git_log(args.dump_path ) _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = MODEL_CLASSES[args.student_type] _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = MODEL_CLASSES[args.teacher_type] # TOKENIZER # _UpperCAmelCase = teacher_tokenizer_class.from_pretrained(args.teacher_name ) _UpperCAmelCase = {} for tok_name, tok_symbol in tokenizer.special_tokens_map.items(): _UpperCAmelCase = tokenizer.all_special_tokens.index(_UpperCAmelCase ) _UpperCAmelCase = tokenizer.all_special_ids[idx] logger.info(F"Special tokens {special_tok_ids}" ) _UpperCAmelCase = special_tok_ids _UpperCAmelCase = 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: _UpperCAmelCase = pickle.load(_UpperCAmelCase ) if args.mlm: logger.info(F"Loading token counts from {args.token_counts} (already pre-computed)" ) with open(args.token_counts , 'rb' ) as fp: _UpperCAmelCase = pickle.load(_UpperCAmelCase ) _UpperCAmelCase = np.maximum(_UpperCAmelCase , 1 ) ** -args.mlm_smoothing for idx in special_tok_ids.values(): _UpperCAmelCase = 0.0 # do not predict special tokens _UpperCAmelCase = torch.from_numpy(_UpperCAmelCase ) else: _UpperCAmelCase = None _UpperCAmelCase = LmSeqsDataset(params=_UpperCAmelCase , data=_UpperCAmelCase ) logger.info('Data loader created.' ) # STUDENT # logger.info(F"Loading student config from {args.student_config}" ) _UpperCAmelCase = student_config_class.from_pretrained(args.student_config ) _UpperCAmelCase = True if args.student_pretrained_weights is not None: logger.info(F"Loading pretrained weights from {args.student_pretrained_weights}" ) _UpperCAmelCase = student_model_class.from_pretrained(args.student_pretrained_weights , config=_UpperCAmelCase ) else: _UpperCAmelCase = student_model_class(_UpperCAmelCase ) if args.n_gpu > 0: student.to(F"cuda:{args.local_rank}" ) logger.info('Student loaded.' ) # TEACHER # _UpperCAmelCase = teacher_model_class.from_pretrained(args.teacher_name , output_hidden_states=_UpperCAmelCase ) 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(_UpperCAmelCase , _UpperCAmelCase ) if args.freeze_token_type_embds: freeze_token_type_embeddings(_UpperCAmelCase , _UpperCAmelCase ) # 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() _UpperCAmelCase = Distiller( params=_UpperCAmelCase , dataset=_UpperCAmelCase , token_probs=_UpperCAmelCase , student=_UpperCAmelCase , teacher=_UpperCAmelCase ) distiller.train() logger.info('Let\'s go get some drinks.' ) if __name__ == "__main__": main()
339
from functools import reduce UpperCAmelCase__ = ( "73167176531330624919225119674426574742355349194934" "96983520312774506326239578318016984801869478851843" "85861560789112949495459501737958331952853208805511" "12540698747158523863050715693290963295227443043557" "66896648950445244523161731856403098711121722383113" "62229893423380308135336276614282806444486645238749" "30358907296290491560440772390713810515859307960866" "70172427121883998797908792274921901699720888093776" "65727333001053367881220235421809751254540594752243" "52584907711670556013604839586446706324415722155397" "53697817977846174064955149290862569321978468622482" "83972241375657056057490261407972968652414535100474" "82166370484403199890008895243450658541227588666881" "16427171479924442928230863465674813919123162824586" "17866458359124566529476545682848912883142607690042" "24219022671055626321111109370544217506941658960408" "07198403850962455444362981230987879927244284909188" "84580156166097919133875499200524063689912560717606" "05886116467109405077541002256983155200055935729725" "71636269561882670428252483600823257530420752963450" ) def A ( _UpperCAmelCase : str = N ) -> int: '''simple docstring''' return max( # mypy cannot properly interpret reduce int(reduce(lambda _UpperCAmelCase , _UpperCAmelCase : str(int(_UpperCAmelCase ) * int(_UpperCAmelCase ) ) , n[i : i + 13] ) ) for i in range(len(_UpperCAmelCase ) - 12 ) ) if __name__ == "__main__": print(f"""{solution() = }""")
339
1
from collections import namedtuple import requests from lxml import html # type: ignore UpperCAmelCase__ = namedtuple("covid_data", "cases deaths recovered") def A ( _UpperCAmelCase : str = "https://www.worldometers.info/coronavirus/" ) -> covid_data: '''simple docstring''' _UpperCAmelCase = '//div[@class = "maincounter-number"]/span/text()' return covid_data(*html.fromstring(requests.get(_UpperCAmelCase ).content ).xpath(_UpperCAmelCase ) ) UpperCAmelCase__ = "Total COVID-19 cases in the world: {}\nTotal deaths due to COVID-19 in the world: {}\nTotal COVID-19 patients recovered in the world: {}" print(fmt.format(*covid_stats()))
339
from __future__ import annotations from collections.abc import Callable UpperCAmelCase__ = list[list[float | int]] def A ( _UpperCAmelCase : Matrix , _UpperCAmelCase : Matrix ) -> Matrix: '''simple docstring''' _UpperCAmelCase = len(_UpperCAmelCase ) _UpperCAmelCase = [[0 for _ in range(size + 1 )] for _ in range(_UpperCAmelCase )] _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 for row in range(_UpperCAmelCase ): for col in range(_UpperCAmelCase ): _UpperCAmelCase = matrix[row][col] _UpperCAmelCase = vector[row][0] _UpperCAmelCase = 0 _UpperCAmelCase = 0 while row < size and col < size: # pivoting _UpperCAmelCase = max((abs(augmented[rowa][col] ), rowa) for rowa in range(_UpperCAmelCase , _UpperCAmelCase ) )[ 1 ] if augmented[pivot_row][col] == 0: col += 1 continue else: _UpperCAmelCase , _UpperCAmelCase = augmented[pivot_row], augmented[row] for rowa in range(row + 1 , _UpperCAmelCase ): _UpperCAmelCase = augmented[rowa][col] / augmented[row][col] _UpperCAmelCase = 0 for cola in range(col + 1 , size + 1 ): augmented[rowa][cola] -= augmented[row][cola] * ratio row += 1 col += 1 # back substitution for col in range(1 , _UpperCAmelCase ): for row in range(_UpperCAmelCase ): _UpperCAmelCase = augmented[row][col] / augmented[col][col] for cola in range(_UpperCAmelCase , size + 1 ): augmented[row][cola] -= augmented[col][cola] * ratio # round to get rid of numbers like 2.000000000000004 return [ [round(augmented[row][size] / augmented[row][row] , 10 )] for row in range(_UpperCAmelCase ) ] def A ( _UpperCAmelCase : list[int] ) -> Callable[[int], int]: '''simple docstring''' _UpperCAmelCase = len(_UpperCAmelCase ) _UpperCAmelCase = [[0 for _ in range(_UpperCAmelCase )] for _ in range(_UpperCAmelCase )] _UpperCAmelCase = [[0] for _ in range(_UpperCAmelCase )] _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 for x_val, y_val in enumerate(_UpperCAmelCase ): for col in range(_UpperCAmelCase ): _UpperCAmelCase = (x_val + 1) ** (size - col - 1) _UpperCAmelCase = y_val _UpperCAmelCase = solve(_UpperCAmelCase , _UpperCAmelCase ) def interpolated_func(_UpperCAmelCase : int ) -> int: return sum( round(coeffs[x_val][0] ) * (var ** (size - x_val - 1)) for x_val in range(_UpperCAmelCase ) ) return interpolated_func def A ( _UpperCAmelCase : int ) -> int: '''simple docstring''' return ( 1 - variable + variable**2 - variable**3 + variable**4 - variable**5 + variable**6 - variable**7 + variable**8 - variable**9 + variable**10 ) def A ( _UpperCAmelCase : Callable[[int], int] = question_function , _UpperCAmelCase : int = 10 ) -> int: '''simple docstring''' _UpperCAmelCase = [func(_UpperCAmelCase ) for x_val in range(1 , order + 1 )] _UpperCAmelCase = [ interpolate(data_points[:max_coeff] ) for max_coeff in range(1 , order + 1 ) ] _UpperCAmelCase = 0 _UpperCAmelCase = 42 _UpperCAmelCase = 42 for poly in polynomials: _UpperCAmelCase = 1 while func(_UpperCAmelCase ) == poly(_UpperCAmelCase ): x_val += 1 ret += poly(_UpperCAmelCase ) return ret if __name__ == "__main__": print(f"""{solution() = }""")
339
1
from __future__ import annotations from collections.abc import Callable UpperCAmelCase__ = list[list[float | int]] def A ( _UpperCAmelCase : Matrix , _UpperCAmelCase : Matrix ) -> Matrix: '''simple docstring''' _UpperCAmelCase = len(_UpperCAmelCase ) _UpperCAmelCase = [[0 for _ in range(size + 1 )] for _ in range(_UpperCAmelCase )] _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 for row in range(_UpperCAmelCase ): for col in range(_UpperCAmelCase ): _UpperCAmelCase = matrix[row][col] _UpperCAmelCase = vector[row][0] _UpperCAmelCase = 0 _UpperCAmelCase = 0 while row < size and col < size: # pivoting _UpperCAmelCase = max((abs(augmented[rowa][col] ), rowa) for rowa in range(_UpperCAmelCase , _UpperCAmelCase ) )[ 1 ] if augmented[pivot_row][col] == 0: col += 1 continue else: _UpperCAmelCase , _UpperCAmelCase = augmented[pivot_row], augmented[row] for rowa in range(row + 1 , _UpperCAmelCase ): _UpperCAmelCase = augmented[rowa][col] / augmented[row][col] _UpperCAmelCase = 0 for cola in range(col + 1 , size + 1 ): augmented[rowa][cola] -= augmented[row][cola] * ratio row += 1 col += 1 # back substitution for col in range(1 , _UpperCAmelCase ): for row in range(_UpperCAmelCase ): _UpperCAmelCase = augmented[row][col] / augmented[col][col] for cola in range(_UpperCAmelCase , size + 1 ): augmented[row][cola] -= augmented[col][cola] * ratio # round to get rid of numbers like 2.000000000000004 return [ [round(augmented[row][size] / augmented[row][row] , 10 )] for row in range(_UpperCAmelCase ) ] def A ( _UpperCAmelCase : list[int] ) -> Callable[[int], int]: '''simple docstring''' _UpperCAmelCase = len(_UpperCAmelCase ) _UpperCAmelCase = [[0 for _ in range(_UpperCAmelCase )] for _ in range(_UpperCAmelCase )] _UpperCAmelCase = [[0] for _ in range(_UpperCAmelCase )] _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 for x_val, y_val in enumerate(_UpperCAmelCase ): for col in range(_UpperCAmelCase ): _UpperCAmelCase = (x_val + 1) ** (size - col - 1) _UpperCAmelCase = y_val _UpperCAmelCase = solve(_UpperCAmelCase , _UpperCAmelCase ) def interpolated_func(_UpperCAmelCase : int ) -> int: return sum( round(coeffs[x_val][0] ) * (var ** (size - x_val - 1)) for x_val in range(_UpperCAmelCase ) ) return interpolated_func def A ( _UpperCAmelCase : int ) -> int: '''simple docstring''' return ( 1 - variable + variable**2 - variable**3 + variable**4 - variable**5 + variable**6 - variable**7 + variable**8 - variable**9 + variable**10 ) def A ( _UpperCAmelCase : Callable[[int], int] = question_function , _UpperCAmelCase : int = 10 ) -> int: '''simple docstring''' _UpperCAmelCase = [func(_UpperCAmelCase ) for x_val in range(1 , order + 1 )] _UpperCAmelCase = [ interpolate(data_points[:max_coeff] ) for max_coeff in range(1 , order + 1 ) ] _UpperCAmelCase = 0 _UpperCAmelCase = 42 _UpperCAmelCase = 42 for poly in polynomials: _UpperCAmelCase = 1 while func(_UpperCAmelCase ) == poly(_UpperCAmelCase ): x_val += 1 ret += poly(_UpperCAmelCase ) return ret if __name__ == "__main__": print(f"""{solution() = }""")
339
from __future__ import annotations def A ( _UpperCAmelCase : list[int] ) -> bool: '''simple docstring''' return len(set(_UpperCAmelCase ) ) == len(_UpperCAmelCase ) if __name__ == "__main__": import doctest doctest.testmod()
339
1
import sys from collections import defaultdict class __lowerCAmelCase : def __init__( self : int) -> str: """simple docstring""" _UpperCAmelCase = [] def _lowerCamelCase ( self : Any , A : List[str]) -> int: """simple docstring""" return self.node_position[vertex] def _lowerCamelCase ( self : Optional[Any] , A : Optional[int] , A : str) -> List[str]: """simple docstring""" _UpperCAmelCase = pos def _lowerCamelCase ( self : Tuple , A : Tuple , A : Dict , A : List[str] , A : Optional[Any]) -> Dict: """simple docstring""" if start > size // 2 - 1: return else: if 2 * start + 2 >= size: _UpperCAmelCase = 2 * start + 1 else: if heap[2 * start + 1] < heap[2 * start + 2]: _UpperCAmelCase = 2 * start + 1 else: _UpperCAmelCase = 2 * start + 2 if heap[smallest_child] < heap[start]: _UpperCAmelCase , _UpperCAmelCase = heap[smallest_child], positions[smallest_child] _UpperCAmelCase , _UpperCAmelCase = ( heap[start], positions[start], ) _UpperCAmelCase , _UpperCAmelCase = temp, tempa _UpperCAmelCase = self.get_position(positions[smallest_child]) self.set_position( positions[smallest_child] , self.get_position(positions[start])) self.set_position(positions[start] , A) self.top_to_bottom(A , A , A , A) def _lowerCamelCase ( self : Optional[int] , A : str , A : Optional[Any] , A : Optional[int] , A : str) -> Any: """simple docstring""" _UpperCAmelCase = position[index] while index != 0: _UpperCAmelCase = int((index - 2) / 2) if index % 2 == 0 else int((index - 1) / 2) if val < heap[parent]: _UpperCAmelCase = heap[parent] _UpperCAmelCase = position[parent] self.set_position(position[parent] , A) else: _UpperCAmelCase = val _UpperCAmelCase = temp self.set_position(A , A) break _UpperCAmelCase = parent else: _UpperCAmelCase = val _UpperCAmelCase = temp self.set_position(A , 0) def _lowerCamelCase ( self : Union[str, Any] , A : Optional[int] , A : Tuple) -> str: """simple docstring""" _UpperCAmelCase = len(A) // 2 - 1 for i in range(A , -1 , -1): self.top_to_bottom(A , A , len(A) , A) def _lowerCamelCase ( self : Optional[int] , A : int , A : str) -> List[str]: """simple docstring""" _UpperCAmelCase = positions[0] _UpperCAmelCase = sys.maxsize self.top_to_bottom(A , 0 , len(A) , A) return temp def A ( _UpperCAmelCase : int ) -> Any: '''simple docstring''' _UpperCAmelCase = Heap() _UpperCAmelCase = [0] * len(_UpperCAmelCase ) _UpperCAmelCase = [-1] * len(_UpperCAmelCase ) # Neighboring Tree Vertex of selected vertex # Minimum Distance of explored vertex with neighboring vertex of partial tree # formed in graph _UpperCAmelCase = [] # Heap of Distance of vertices from their neighboring vertex _UpperCAmelCase = [] for vertex in range(len(_UpperCAmelCase ) ): distance_tv.append(sys.maxsize ) positions.append(_UpperCAmelCase ) heap.node_position.append(_UpperCAmelCase ) _UpperCAmelCase = [] _UpperCAmelCase = 1 _UpperCAmelCase = sys.maxsize for neighbor, distance in adjacency_list[0]: _UpperCAmelCase = 0 _UpperCAmelCase = distance heap.heapify(_UpperCAmelCase , _UpperCAmelCase ) for _ in range(1 , len(_UpperCAmelCase ) ): _UpperCAmelCase = heap.delete_minimum(_UpperCAmelCase , _UpperCAmelCase ) if visited[vertex] == 0: tree_edges.append((nbr_tv[vertex], vertex) ) _UpperCAmelCase = 1 for neighbor, distance in adjacency_list[vertex]: if ( visited[neighbor] == 0 and distance < distance_tv[heap.get_position(_UpperCAmelCase )] ): _UpperCAmelCase = distance heap.bottom_to_top( _UpperCAmelCase , heap.get_position(_UpperCAmelCase ) , _UpperCAmelCase , _UpperCAmelCase ) _UpperCAmelCase = vertex return tree_edges if __name__ == "__main__": # pragma: no cover # < --------- Prims Algorithm --------- > UpperCAmelCase__ = int(input("Enter number of edges: ").strip()) UpperCAmelCase__ = defaultdict(list) for _ in range(edges_number): UpperCAmelCase__ = [int(x) for x in input().strip().split()] adjacency_list[edge[0]].append([edge[1], edge[2]]) adjacency_list[edge[1]].append([edge[0], edge[2]]) print(prisms_algorithm(adjacency_list))
339
import os UpperCAmelCase__ = {"I": 1, "V": 5, "X": 10, "L": 50, "C": 100, "D": 500, "M": 1000} def A ( _UpperCAmelCase : str ) -> int: '''simple docstring''' _UpperCAmelCase = 0 _UpperCAmelCase = 0 while index < len(_UpperCAmelCase ) - 1: _UpperCAmelCase = SYMBOLS[numerals[index]] _UpperCAmelCase = SYMBOLS[numerals[index + 1]] if current_value < next_value: total_value -= current_value else: total_value += current_value index += 1 total_value += SYMBOLS[numerals[index]] return total_value def A ( _UpperCAmelCase : int ) -> str: '''simple docstring''' _UpperCAmelCase = '' _UpperCAmelCase = num // 1_000 numerals += m_count * "M" num %= 1_000 _UpperCAmelCase = num // 100 if c_count == 9: numerals += "CM" c_count -= 9 elif c_count == 4: numerals += "CD" c_count -= 4 if c_count >= 5: numerals += "D" c_count -= 5 numerals += c_count * "C" num %= 100 _UpperCAmelCase = num // 10 if x_count == 9: numerals += "XC" x_count -= 9 elif x_count == 4: numerals += "XL" x_count -= 4 if x_count >= 5: numerals += "L" x_count -= 5 numerals += x_count * "X" num %= 10 if num == 9: numerals += "IX" num -= 9 elif num == 4: numerals += "IV" num -= 4 if num >= 5: numerals += "V" num -= 5 numerals += num * "I" return numerals def A ( _UpperCAmelCase : str = "/p089_roman.txt" ) -> int: '''simple docstring''' _UpperCAmelCase = 0 with open(os.path.dirname(_UpperCAmelCase ) + roman_numerals_filename ) as filea: _UpperCAmelCase = filea.readlines() for line in lines: _UpperCAmelCase = line.strip() _UpperCAmelCase = parse_roman_numerals(_UpperCAmelCase ) _UpperCAmelCase = generate_roman_numerals(_UpperCAmelCase ) savings += len(_UpperCAmelCase ) - len(_UpperCAmelCase ) return savings if __name__ == "__main__": print(f"""{solution() = }""")
339
1
def A ( _UpperCAmelCase : int ) -> int: '''simple docstring''' if not isinstance(_UpperCAmelCase , _UpperCAmelCase ): _UpperCAmelCase = F"Input value of [number={number}] must be an integer" raise TypeError(_UpperCAmelCase ) if number < 1: _UpperCAmelCase = F"Input value of [number={number}] must be > 0" raise ValueError(_UpperCAmelCase ) _UpperCAmelCase = 1 for i in range(1 , _UpperCAmelCase ): current_number *= 4 * i - 2 current_number //= i + 1 return current_number if __name__ == "__main__": import doctest doctest.testmod()
339
import requests from bsa import BeautifulSoup def A ( _UpperCAmelCase : str , _UpperCAmelCase : dict ) -> str: '''simple docstring''' _UpperCAmelCase = BeautifulSoup(requests.get(_UpperCAmelCase , params=_UpperCAmelCase ).content , 'html.parser' ) _UpperCAmelCase = soup.find('div' , attrs={'class': 'gs_ri'} ) _UpperCAmelCase = div.find('div' , attrs={'class': 'gs_fl'} ).find_all('a' ) return anchors[2].get_text() if __name__ == "__main__": UpperCAmelCase__ = { "title": ( "Precisely geometry controlled microsupercapacitors for ultrahigh areal " "capacitance, volumetric capacitance, and energy density" ), "journal": "Chem. Mater.", "volume": 30, "pages": "3979-3990", "year": 2018, "hl": "en", } print(get_citation("https://scholar.google.com/scholar_lookup", params=params))
339
1
import json import os from typing import Dict, List, Optional, Tuple import regex as re from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging UpperCAmelCase__ = logging.get_logger(__name__) UpperCAmelCase__ = { "vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_config_file": "tokenizer_config.json", } UpperCAmelCase__ = { "vocab_file": { "facebook/blenderbot_small-90M": "https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/vocab.json" }, "merges_file": { "facebook/blenderbot_small-90M": "https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/merges.txt" }, "tokenizer_config_file": { "facebook/blenderbot_small-90M": ( "https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/tokenizer_config.json" ) }, } UpperCAmelCase__ = {"facebook/blenderbot_small-90M": 512} def A ( _UpperCAmelCase : Tuple ) -> str: '''simple docstring''' _UpperCAmelCase = set() _UpperCAmelCase = word[0] for char in word[1:]: pairs.add((prev_char, char) ) _UpperCAmelCase = char _UpperCAmelCase = set(_UpperCAmelCase ) return pairs class __lowerCAmelCase ( A ): UpperCamelCase = VOCAB_FILES_NAMES UpperCamelCase = PRETRAINED_VOCAB_FILES_MAP UpperCamelCase = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES UpperCamelCase = ['''input_ids''', '''attention_mask'''] def __init__( self : Optional[Any] , A : str , A : List[str] , A : Union[str, Any]="__start__" , A : Optional[Any]="__end__" , A : Optional[int]="__unk__" , A : Any="__null__" , **A : Dict , ) -> Optional[Any]: """simple docstring""" super().__init__(unk_token=A , bos_token=A , eos_token=A , pad_token=A , **A) with open(A , encoding='utf-8') as vocab_handle: _UpperCAmelCase = json.load(A) _UpperCAmelCase = {v: k for k, v in self.encoder.items()} with open(A , encoding='utf-8') as merges_handle: _UpperCAmelCase = merges_handle.read().split('\n')[1:-1] _UpperCAmelCase = [tuple(merge.split()) for merge in merges] _UpperCAmelCase = dict(zip(A , range(len(A)))) _UpperCAmelCase = {} @property def _lowerCamelCase ( self : Tuple) -> int: """simple docstring""" return len(self.encoder) def _lowerCamelCase ( self : List[Any]) -> Dict: """simple docstring""" return dict(self.encoder , **self.added_tokens_encoder) def _lowerCamelCase ( self : Dict , A : str) -> str: """simple docstring""" if token in self.cache: return self.cache[token] _UpperCAmelCase = re.sub('([.,!?()])' , R' \1' , A) _UpperCAmelCase = re.sub('(\')' , R' \1 ' , A) _UpperCAmelCase = re.sub(R'\s{2,}' , ' ' , A) if "\n" in token: _UpperCAmelCase = token.replace('\n' , ' __newln__') _UpperCAmelCase = token.split(' ') _UpperCAmelCase = [] for token in tokens: if not len(A): continue _UpperCAmelCase = token.lower() _UpperCAmelCase = tuple(A) _UpperCAmelCase = tuple(list(word[:-1]) + [word[-1] + '</w>']) _UpperCAmelCase = get_pairs(A) if not pairs: words.append(A) continue while True: _UpperCAmelCase = min(A , key=lambda A: self.bpe_ranks.get(A , float('inf'))) if bigram not in self.bpe_ranks: break _UpperCAmelCase , _UpperCAmelCase = bigram _UpperCAmelCase = [] _UpperCAmelCase = 0 while i < len(A): try: _UpperCAmelCase = word.index(A , A) new_word.extend(word[i:j]) _UpperCAmelCase = j except ValueError: new_word.extend(word[i:]) break if word[i] == first and i < len(A) - 1 and word[i + 1] == second: new_word.append(first + second) i += 2 else: new_word.append(word[i]) i += 1 _UpperCAmelCase = tuple(A) _UpperCAmelCase = new_word if len(A) == 1: break else: _UpperCAmelCase = get_pairs(A) _UpperCAmelCase = '@@ '.join(A) _UpperCAmelCase = word[:-4] _UpperCAmelCase = word words.append(A) return " ".join(A) def _lowerCamelCase ( self : List[Any] , A : str) -> List[str]: """simple docstring""" _UpperCAmelCase = [] _UpperCAmelCase = re.findall(R'\S+\n?' , A) for token in words: split_tokens.extend(list(self.bpe(A).split(' '))) return split_tokens def _lowerCamelCase ( self : List[Any] , A : str) -> int: """simple docstring""" _UpperCAmelCase = token.lower() return self.encoder.get(A , self.encoder.get(self.unk_token)) def _lowerCamelCase ( self : Any , A : int) -> str: """simple docstring""" return self.decoder.get(A , self.unk_token) def _lowerCamelCase ( self : int , A : List[str]) -> str: """simple docstring""" _UpperCAmelCase = ' '.join(A).replace('@@ ' , '').strip() return out_string def _lowerCamelCase ( self : int , A : str , A : Optional[str] = None) -> Tuple[str]: """simple docstring""" if not os.path.isdir(A): logger.error(F"Vocabulary path ({save_directory}) should be a directory") return _UpperCAmelCase = os.path.join( A , (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']) _UpperCAmelCase = os.path.join( A , (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['merges_file']) with open(A , 'w' , encoding='utf-8') as f: f.write(json.dumps(self.encoder , indent=2 , sort_keys=A , ensure_ascii=A) + '\n') _UpperCAmelCase = 0 with open(A , 'w' , encoding='utf-8') as writer: writer.write('#version: 0.2\n') for bpe_tokens, token_index in sorted(self.bpe_ranks.items() , key=lambda A: kv[1]): if index != token_index: logger.warning( F"Saving vocabulary to {merge_file}: BPE merge indices are not consecutive." ' Please check that the tokenizer is not corrupted!') _UpperCAmelCase = token_index writer.write(' '.join(A) + '\n') index += 1 return vocab_file, merge_file
339
import unittest import numpy as np from transformers import RoFormerConfig, 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.roformer.modeling_flax_roformer import ( FlaxRoFormerForMaskedLM, FlaxRoFormerForMultipleChoice, FlaxRoFormerForQuestionAnswering, FlaxRoFormerForSequenceClassification, FlaxRoFormerForTokenClassification, FlaxRoFormerModel, ) class __lowerCAmelCase ( unittest.TestCase ): def __init__( self : Optional[Any] , A : Dict , A : Union[str, Any]=13 , A : Dict=7 , A : Dict=True , A : Tuple=True , A : Union[str, Any]=True , A : int=True , A : Optional[int]=99 , A : List[str]=32 , A : List[Any]=5 , A : int=4 , A : Any=37 , A : Optional[int]="gelu" , A : Optional[Any]=0.1 , A : Any=0.1 , A : Union[str, Any]=5_12 , A : int=16 , A : List[str]=2 , A : Union[str, Any]=0.0_2 , A : Union[str, Any]=4 , ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = seq_length _UpperCAmelCase = is_training _UpperCAmelCase = use_attention_mask _UpperCAmelCase = use_token_type_ids _UpperCAmelCase = use_labels _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = type_vocab_size _UpperCAmelCase = type_sequence_label_size _UpperCAmelCase = initializer_range _UpperCAmelCase = num_choices def _lowerCamelCase ( self : Optional[Any]) -> List[Any]: """simple docstring""" _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size) _UpperCAmelCase = None if self.use_attention_mask: _UpperCAmelCase = random_attention_mask([self.batch_size, self.seq_length]) _UpperCAmelCase = None if self.use_token_type_ids: _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size) _UpperCAmelCase = RoFormerConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , is_decoder=A , initializer_range=self.initializer_range , ) return config, input_ids, token_type_ids, attention_mask def _lowerCamelCase ( self : List[Any]) -> List[str]: """simple docstring""" _UpperCAmelCase = self.prepare_config_and_inputs() _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = config_and_inputs _UpperCAmelCase = {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': attention_mask} return config, inputs_dict @require_flax class __lowerCAmelCase ( A , unittest.TestCase ): UpperCamelCase = True UpperCamelCase = ( ( FlaxRoFormerModel, FlaxRoFormerForMaskedLM, FlaxRoFormerForSequenceClassification, FlaxRoFormerForTokenClassification, FlaxRoFormerForMultipleChoice, FlaxRoFormerForQuestionAnswering, ) if is_flax_available() else () ) def _lowerCamelCase ( self : Optional[int]) -> Any: """simple docstring""" _UpperCAmelCase = FlaxRoFormerModelTester(self) @slow def _lowerCamelCase ( self : List[Any]) -> Dict: """simple docstring""" for model_class_name in self.all_model_classes: _UpperCAmelCase = model_class_name.from_pretrained('junnyu/roformer_chinese_small' , from_pt=A) _UpperCAmelCase = model(np.ones((1, 1))) self.assertIsNotNone(A) @require_flax class __lowerCAmelCase ( unittest.TestCase ): @slow def _lowerCamelCase ( self : List[Any]) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = FlaxRoFormerForMaskedLM.from_pretrained('junnyu/roformer_chinese_base') _UpperCAmelCase = jnp.array([[0, 1, 2, 3, 4, 5]]) _UpperCAmelCase = model(A)[0] _UpperCAmelCase = 5_00_00 _UpperCAmelCase = (1, 6, vocab_size) self.assertEqual(output.shape , A) _UpperCAmelCase = jnp.array( [[[-0.1_2_0_5, -1.0_2_6_5, 0.2_9_2_2], [-1.5_1_3_4, 0.1_9_7_4, 0.1_5_1_9], [-5.0_1_3_5, -3.9_0_0_3, -0.8_4_0_4]]]) self.assertTrue(jnp.allclose(output[:, :3, :3] , A , atol=1E-4))
339
1
from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCAmelCase__ = logging.get_logger(__name__) UpperCAmelCase__ = { "RWKV/rwkv-4-169m-pile": "https://huggingface.co/RWKV/rwkv-4-169m-pile/resolve/main/config.json", "RWKV/rwkv-4-430m-pile": "https://huggingface.co/RWKV/rwkv-4-430m-pile/resolve/main/config.json", "RWKV/rwkv-4-1b5-pile": "https://huggingface.co/RWKV/rwkv-4-1b5-pile/resolve/main/config.json", "RWKV/rwkv-4-3b-pile": "https://huggingface.co/RWKV/rwkv-4-3b-pile/resolve/main/config.json", "RWKV/rwkv-4-7b-pile": "https://huggingface.co/RWKV/rwkv-4-7b-pile/resolve/main/config.json", "RWKV/rwkv-4-14b-pile": "https://huggingface.co/RWKV/rwkv-4-14b-pile/resolve/main/config.json", "RWKV/rwkv-raven-1b5": "https://huggingface.co/RWKV/rwkv-raven-1b5/resolve/main/config.json", "RWKV/rwkv-raven-3b": "https://huggingface.co/RWKV/rwkv-raven-3b/resolve/main/config.json", "RWKV/rwkv-raven-7b": "https://huggingface.co/RWKV/rwkv-raven-7b/resolve/main/config.json", "RWKV/rwkv-raven-14b": "https://huggingface.co/RWKV/rwkv-raven-14b/resolve/main/config.json", } class __lowerCAmelCase ( A ): UpperCamelCase = '''rwkv''' UpperCamelCase = {'''max_position_embeddings''': '''context_length'''} def __init__( self : Tuple , A : List[str]=5_02_77 , A : int=10_24 , A : Dict=40_96 , A : Union[str, Any]=32 , A : Tuple=None , A : Optional[Any]=None , A : List[str]=1E-5 , A : Optional[int]=0 , A : str=0 , A : Any=6 , A : List[Any]=False , A : str=True , **A : Union[str, Any] , ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = vocab_size _UpperCAmelCase = context_length _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = attention_hidden_size if attention_hidden_size is not None else hidden_size _UpperCAmelCase = intermediate_size if intermediate_size is not None else 4 * hidden_size _UpperCAmelCase = layer_norm_epsilon _UpperCAmelCase = rescale_every _UpperCAmelCase = use_cache _UpperCAmelCase = bos_token_id _UpperCAmelCase = eos_token_id super().__init__( tie_word_embeddings=A , bos_token_id=A , eos_token_id=A , **A)
339
UpperCAmelCase__ = {} def A ( _UpperCAmelCase : int , _UpperCAmelCase : int , _UpperCAmelCase : int ) -> int: '''simple docstring''' # if we are absent twice, or late 3 consecutive days, # no further prize strings are possible if late == 3 or absent == 2: return 0 # if we have no days left, and have not failed any other rules, # we have a prize string if days == 0: return 1 # No easy solution, so now we need to do the recursive calculation # First, check if the combination is already in the cache, and # if yes, return the stored value from there since we already # know the number of possible prize strings from this point on _UpperCAmelCase = (days, absent, late) if key in cache: return cache[key] # now we calculate the three possible ways that can unfold from # this point on, depending on our attendance today # 1) if we are late (but not absent), the "absent" counter stays as # it is, but the "late" counter increases by one _UpperCAmelCase = _calculate(days - 1 , _UpperCAmelCase , late + 1 ) # 2) if we are absent, the "absent" counter increases by 1, and the # "late" counter resets to 0 _UpperCAmelCase = _calculate(days - 1 , absent + 1 , 0 ) # 3) if we are on time, this resets the "late" counter and keeps the # absent counter _UpperCAmelCase = _calculate(days - 1 , _UpperCAmelCase , 0 ) _UpperCAmelCase = state_late + state_absent + state_ontime _UpperCAmelCase = prizestrings return prizestrings def A ( _UpperCAmelCase : int = 30 ) -> int: '''simple docstring''' return _calculate(_UpperCAmelCase , absent=0 , late=0 ) if __name__ == "__main__": print(solution())
339
1
from . import ( albert, align, altclip, audio_spectrogram_transformer, auto, autoformer, bark, bart, barthez, bartpho, beit, bert, bert_generation, bert_japanese, bertweet, big_bird, bigbird_pegasus, biogpt, bit, blenderbot, blenderbot_small, blip, blip_a, bloom, bridgetower, byta, camembert, canine, chinese_clip, clap, clip, clipseg, codegen, conditional_detr, convbert, convnext, convnextva, cpm, cpmant, ctrl, cvt, dataavec, deberta, deberta_va, decision_transformer, deformable_detr, deit, deprecated, deta, detr, dialogpt, dinat, distilbert, dit, donut, dpr, dpt, efficientformer, efficientnet, electra, encodec, encoder_decoder, ernie, ernie_m, esm, falcon, flaubert, flava, fnet, focalnet, fsmt, funnel, git, glpn, gpta, gpt_bigcode, gpt_neo, gpt_neox, gpt_neox_japanese, gpt_swa, gptj, gptsan_japanese, graphormer, groupvit, herbert, hubert, ibert, imagegpt, informer, instructblip, jukebox, layoutlm, layoutlmva, layoutlmva, layoutxlm, led, levit, lilt, llama, longformer, longta, luke, lxmert, mam_aaa, marian, markuplm, maskaformer, maskformer, mbart, mbartaa, mega, megatron_bert, megatron_gpta, mgp_str, mluke, mobilebert, mobilenet_va, mobilenet_va, mobilevit, mobilevitva, mpnet, mra, mta, musicgen, mvp, nat, nezha, nllb, nllb_moe, nystromformer, oneformer, open_llama, openai, opt, owlvit, pegasus, pegasus_x, perceiver, phobert, pixastruct, plbart, poolformer, prophetnet, qdqbert, rag, realm, reformer, regnet, rembert, resnet, roberta, roberta_prelayernorm, roc_bert, roformer, rwkv, sam, segformer, sew, sew_d, speech_encoder_decoder, speech_to_text, speech_to_text_a, speechta, splinter, squeezebert, swiftformer, swin, swinasr, swinva, switch_transformers, ta, table_transformer, tapas, time_series_transformer, timesformer, timm_backbone, transfo_xl, trocr, tvlt, umta, unispeech, unispeech_sat, upernet, videomae, vilt, vision_encoder_decoder, vision_text_dual_encoder, visual_bert, vit, vit_hybrid, vit_mae, vit_msn, vivit, wavaveca, wavaveca_conformer, wavaveca_phoneme, wavaveca_with_lm, wavlm, whisper, x_clip, xglm, xlm, xlm_prophetnet, xlm_roberta, xlm_roberta_xl, xlnet, xmod, yolos, yoso, )
339
import os import sys import unittest UpperCAmelCase__ = 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_dummies # noqa: E402 from check_dummies import create_dummy_files, create_dummy_object, find_backend, read_init # noqa: E402 # Align TRANSFORMERS_PATH in check_dummies with the current path UpperCAmelCase__ = os.path.join(git_repo_path, "src", "diffusers") class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Tuple) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = find_backend(' if not is_torch_available():') self.assertEqual(A , 'torch') # backend_with_underscore = find_backend(" if not is_tensorflow_text_available():") # self.assertEqual(backend_with_underscore, "tensorflow_text") _UpperCAmelCase = find_backend(' if not (is_torch_available() and is_transformers_available()):') self.assertEqual(A , 'torch_and_transformers') # double_backend_with_underscore = find_backend( # " if not (is_sentencepiece_available() and is_tensorflow_text_available()):" # ) # self.assertEqual(double_backend_with_underscore, "sentencepiece_and_tensorflow_text") _UpperCAmelCase = find_backend( ' if not (is_torch_available() and is_transformers_available() and is_onnx_available()):') self.assertEqual(A , 'torch_and_transformers_and_onnx') def _lowerCamelCase ( self : int) -> Dict: """simple docstring""" _UpperCAmelCase = read_init() # We don't assert on the exact list of keys to allow for smooth grow of backend-specific objects self.assertIn('torch' , A) self.assertIn('torch_and_transformers' , A) self.assertIn('flax_and_transformers' , A) self.assertIn('torch_and_transformers_and_onnx' , A) # Likewise, we can't assert on the exact content of a key self.assertIn('UNet2DModel' , objects['torch']) self.assertIn('FlaxUNet2DConditionModel' , objects['flax']) self.assertIn('StableDiffusionPipeline' , objects['torch_and_transformers']) self.assertIn('FlaxStableDiffusionPipeline' , objects['flax_and_transformers']) self.assertIn('LMSDiscreteScheduler' , objects['torch_and_scipy']) self.assertIn('OnnxStableDiffusionPipeline' , objects['torch_and_transformers_and_onnx']) def _lowerCamelCase ( self : Union[str, Any]) -> List[Any]: """simple docstring""" _UpperCAmelCase = create_dummy_object('CONSTANT' , '\'torch\'') self.assertEqual(A , '\nCONSTANT = None\n') _UpperCAmelCase = create_dummy_object('function' , '\'torch\'') self.assertEqual( A , '\ndef function(*args, **kwargs):\n requires_backends(function, \'torch\')\n') _UpperCAmelCase = '\nclass FakeClass(metaclass=DummyObject):\n _backends = \'torch\'\n\n def __init__(self, *args, **kwargs):\n requires_backends(self, \'torch\')\n\n @classmethod\n def from_config(cls, *args, **kwargs):\n requires_backends(cls, \'torch\')\n\n @classmethod\n def from_pretrained(cls, *args, **kwargs):\n requires_backends(cls, \'torch\')\n' _UpperCAmelCase = create_dummy_object('FakeClass' , '\'torch\'') self.assertEqual(A , A) def _lowerCamelCase ( self : Dict) -> int: """simple docstring""" _UpperCAmelCase = '# This file is autogenerated by the command `make fix-copies`, do not edit.\nfrom ..utils import DummyObject, requires_backends\n\n\nCONSTANT = None\n\n\ndef function(*args, **kwargs):\n requires_backends(function, ["torch"])\n\n\nclass FakeClass(metaclass=DummyObject):\n _backends = ["torch"]\n\n def __init__(self, *args, **kwargs):\n requires_backends(self, ["torch"])\n\n @classmethod\n def from_config(cls, *args, **kwargs):\n requires_backends(cls, ["torch"])\n\n @classmethod\n def from_pretrained(cls, *args, **kwargs):\n requires_backends(cls, ["torch"])\n' _UpperCAmelCase = create_dummy_files({'torch': ['CONSTANT', 'function', 'FakeClass']}) self.assertEqual(dummy_files['torch'] , A)
339
1
from typing import Optional import numpy as np import torch from torch import nn from transformers import GPTaConfig, GPTaLMHeadModel from transformers.modeling_utils import ModuleUtilsMixin from ...configuration_utils import ConfigMixin, register_to_config from ...models import ModelMixin class __lowerCAmelCase ( A , A , A ): UpperCamelCase = [R'''h\.\d+\.attn\.bias''', R'''h\.\d+\.attn\.masked_bias'''] @register_to_config def __init__( self : Optional[Any] , A : int , A : int , A : Optional[int] = None , A : int = 5_02_57 , A : int = 10_24 , A : int = 7_68 , A : int = 12 , A : int = 12 , A : Optional[int] = None , A : str = "gelu_new" , A : float = 0.1 , A : float = 0.1 , A : float = 0.1 , A : float = 1E-5 , A : float = 0.0_2 , A : bool = True , A : bool = True , A : bool = False , A : bool = False , ) -> Dict: """simple docstring""" super().__init__() _UpperCAmelCase = prefix_length if prefix_inner_dim != n_embd and prefix_hidden_dim is None: raise ValueError( F"`prefix_hidden_dim` cannot be `None` when `prefix_inner_dim`: {prefix_hidden_dim} and" F" `n_embd`: {n_embd} are not equal.") _UpperCAmelCase = prefix_inner_dim _UpperCAmelCase = prefix_hidden_dim _UpperCAmelCase = ( nn.Linear(self.prefix_inner_dim , self.prefix_hidden_dim) if self.prefix_hidden_dim is not None else nn.Identity() ) _UpperCAmelCase = ( nn.Linear(self.prefix_hidden_dim , A) if self.prefix_hidden_dim is not None else nn.Identity() ) _UpperCAmelCase = GPTaConfig( vocab_size=A , n_positions=A , n_embd=A , n_layer=A , n_head=A , n_inner=A , activation_function=A , resid_pdrop=A , embd_pdrop=A , attn_pdrop=A , layer_norm_epsilon=A , initializer_range=A , scale_attn_weights=A , use_cache=A , scale_attn_by_inverse_layer_idx=A , reorder_and_upcast_attn=A , ) _UpperCAmelCase = GPTaLMHeadModel(A) def _lowerCamelCase ( self : Tuple , A : torch.Tensor , A : torch.Tensor , A : Optional[torch.Tensor] = None , A : Optional[torch.Tensor] = None , ) -> str: """simple docstring""" _UpperCAmelCase = self.transformer.transformer.wte(A) _UpperCAmelCase = self.encode_prefix(A) _UpperCAmelCase = self.decode_prefix(A) _UpperCAmelCase = torch.cat((prefix_embeds, embedding_text) , dim=1) if labels is not None: _UpperCAmelCase = self.get_dummy_token(input_ids.shape[0] , input_ids.device) _UpperCAmelCase = torch.cat((dummy_token, input_ids) , dim=1) _UpperCAmelCase = self.transformer(inputs_embeds=A , labels=A , attention_mask=A) if self.prefix_hidden_dim is not None: return out, hidden else: return out def _lowerCamelCase ( self : str , A : int , A : torch.device) -> torch.Tensor: """simple docstring""" return torch.zeros(A , self.prefix_length , dtype=torch.intaa , device=A) def _lowerCamelCase ( self : str , A : List[str]) -> int: """simple docstring""" return self.encode_prefix(A) @torch.no_grad() def _lowerCamelCase ( self : List[Any] , A : int , A : Dict , A : Optional[int]) -> Optional[int]: """simple docstring""" _UpperCAmelCase = torch.split(A , 1 , dim=0) _UpperCAmelCase = [] _UpperCAmelCase = [] for feature in features: _UpperCAmelCase = self.decode_prefix(feature.to(A)) # back to the clip feature # Only support beam search for now _UpperCAmelCase , _UpperCAmelCase = self.generate_beam( input_embeds=A , device=A , eos_token_id=A) generated_tokens.append(output_tokens[0]) generated_seq_lengths.append(seq_lengths[0]) _UpperCAmelCase = torch.stack(A) _UpperCAmelCase = torch.stack(A) return generated_tokens, generated_seq_lengths @torch.no_grad() def _lowerCamelCase ( self : int , A : List[Any]=None , A : Tuple=None , A : List[Any]=None , A : int = 5 , A : int = 67 , A : float = 1.0 , A : Optional[int] = None , ) -> int: """simple docstring""" _UpperCAmelCase = eos_token_id _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = torch.ones(A , device=A , dtype=torch.int) _UpperCAmelCase = torch.zeros(A , device=A , dtype=torch.bool) if input_embeds is not None: _UpperCAmelCase = input_embeds else: _UpperCAmelCase = self.transformer.transformer.wte(A) for i in range(A): _UpperCAmelCase = self.transformer(inputs_embeds=A) _UpperCAmelCase = outputs.logits _UpperCAmelCase = logits[:, -1, :] / (temperature if temperature > 0 else 1.0) _UpperCAmelCase = logits.softmax(-1).log() if scores is None: _UpperCAmelCase , _UpperCAmelCase = logits.topk(A , -1) _UpperCAmelCase = generated.expand(A , *generated.shape[1:]) _UpperCAmelCase , _UpperCAmelCase = next_tokens.permute(1 , 0), scores.squeeze(0) if tokens is None: _UpperCAmelCase = next_tokens else: _UpperCAmelCase = tokens.expand(A , *tokens.shape[1:]) _UpperCAmelCase = torch.cat((tokens, next_tokens) , dim=1) else: _UpperCAmelCase = -float(np.inf) _UpperCAmelCase = 0 _UpperCAmelCase = scores[:, None] + logits seq_lengths[~is_stopped] += 1 _UpperCAmelCase = scores_sum / seq_lengths[:, None] _UpperCAmelCase , _UpperCAmelCase = scores_sum_average.view(-1).topk(A , -1) _UpperCAmelCase = next_tokens // scores_sum.shape[1] _UpperCAmelCase = seq_lengths[next_tokens_source] _UpperCAmelCase = next_tokens % scores_sum.shape[1] _UpperCAmelCase = next_tokens.unsqueeze(1) _UpperCAmelCase = tokens[next_tokens_source] _UpperCAmelCase = torch.cat((tokens, next_tokens) , dim=1) _UpperCAmelCase = generated[next_tokens_source] _UpperCAmelCase = scores_sum_average * seq_lengths _UpperCAmelCase = is_stopped[next_tokens_source] _UpperCAmelCase = self.transformer.transformer.wte(next_tokens.squeeze()).view(generated.shape[0] , 1 , -1) _UpperCAmelCase = torch.cat((generated, next_token_embed) , dim=1) _UpperCAmelCase = is_stopped + next_tokens.eq(A).squeeze() if is_stopped.all(): break _UpperCAmelCase = scores / seq_lengths _UpperCAmelCase = scores.argsort(descending=A) # tokens tensors are already padded to max_seq_length _UpperCAmelCase = [tokens[i] for i in order] _UpperCAmelCase = torch.stack(A , dim=0) _UpperCAmelCase = torch.tensor([seq_lengths[i] for i in order] , dtype=seq_lengths.dtype) return output_texts, seq_lengths
339
import logging import os import random import sys from dataclasses import dataclass, field from typing import Optional import datasets import numpy as np import pandas as pd from datasets import load_dataset import transformers from transformers import ( AutoConfig, BartForSequenceClassification, DataCollatorWithPadding, EvalPrediction, HfArgumentParser, TapexTokenizer, Trainer, TrainingArguments, default_data_collator, set_seed, ) from transformers.trainer_utils import get_last_checkpoint from transformers.utils import check_min_version from transformers.utils.versions import require_version # Will error if the minimal version of Transformers is not installed. Remove at your own risks. check_min_version("4.17.0.dev0") require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/text-classification/requirements.txt") UpperCAmelCase__ = logging.getLogger(__name__) @dataclass class __lowerCAmelCase : UpperCamelCase = field( default='''tab_fact''' , metadata={'''help''': '''The name of the dataset to use (via the datasets library).'''} ) UpperCamelCase = field( default='''tab_fact''' , metadata={'''help''': '''The configuration name of the dataset to use (via the datasets library).'''} , ) UpperCamelCase = field( default=1_0_2_4 , metadata={ '''help''': ( '''The maximum total input sequence length after tokenization. Sequences longer ''' '''than this will be truncated, sequences shorter will be padded.''' ) } , ) UpperCamelCase = field( default=A , metadata={'''help''': '''Overwrite the cached preprocessed datasets or not.'''} ) UpperCamelCase = field( default=A , 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.''' ) } , ) UpperCamelCase = field( default=A , metadata={ '''help''': ( '''For debugging purposes or quicker training, truncate the number of training examples to this ''' '''value if set.''' ) } , ) UpperCamelCase = field( default=A , metadata={ '''help''': ( '''For debugging purposes or quicker training, truncate the number of evaluation examples to this ''' '''value if set.''' ) } , ) UpperCamelCase = field( default=A , metadata={ '''help''': ( '''For debugging purposes or quicker training, truncate the number of prediction examples to this ''' '''value if set.''' ) } , ) UpperCamelCase = field( default=A , metadata={'''help''': '''A csv or a json file containing the training data.'''} ) UpperCamelCase = field( default=A , metadata={'''help''': '''A csv or a json file containing the validation data.'''} ) UpperCamelCase = field(default=A , metadata={'''help''': '''A csv or a json file containing the test data.'''} ) def _lowerCamelCase ( self : str) -> List[Any]: """simple docstring""" if self.dataset_name is not None: pass elif self.train_file is None or self.validation_file is None: raise ValueError('Need either a GLUE task, a training/validation file or a dataset name.') else: _UpperCAmelCase = self.train_file.split('.')[-1] assert train_extension in ["csv", "json"], "`train_file` should be a csv or a json file." _UpperCAmelCase = self.validation_file.split('.')[-1] assert ( validation_extension == train_extension ), "`validation_file` should have the same extension (csv or json) as `train_file`." @dataclass class __lowerCAmelCase : UpperCamelCase = field( default=A , metadata={'''help''': '''Path to pretrained model or model identifier from huggingface.co/models'''} ) UpperCamelCase = field( default=A , metadata={'''help''': '''Pretrained config name or path if not the same as model_name'''} ) UpperCamelCase = field( default=A , metadata={'''help''': '''Pretrained tokenizer name or path if not the same as model_name'''} ) UpperCamelCase = field( default=A , metadata={'''help''': '''Where do you want to store the pretrained models downloaded from huggingface.co'''} , ) UpperCamelCase = field( default=A , metadata={'''help''': '''Whether to use one of the fast tokenizer (backed by the tokenizers library) or not.'''} , ) UpperCamelCase = field( default='''main''' , metadata={'''help''': '''The specific model version to use (can be a branch name, tag name or commit id).'''} , ) UpperCamelCase = field( default=A , metadata={ '''help''': ( '''Will use the token generated when running `huggingface-cli login` (necessary to use this script ''' '''with private models).''' ) } , ) def A ( ) -> Optional[int]: '''simple docstring''' # See all possible arguments in src/transformers/training_args.py # or by passing the --help flag to this script. # We now keep distinct sets of args, for a cleaner separation of concerns. _UpperCAmelCase = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments) ) if len(sys.argv ) == 2 and sys.argv[1].endswith('.json' ): # If we pass only one argument to the script and it's the path to a json file, # let's parse it to get our arguments. _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1] ) ) else: _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = parser.parse_args_into_dataclasses() # Setup logging logging.basicConfig( format='%(asctime)s - %(levelname)s - %(name)s - %(message)s' , datefmt='%m/%d/%Y %H:%M:%S' , handlers=[logging.StreamHandler(sys.stdout )] , ) _UpperCAmelCase = training_args.get_process_log_level() logger.setLevel(_UpperCAmelCase ) datasets.utils.logging.set_verbosity(_UpperCAmelCase ) transformers.utils.logging.set_verbosity(_UpperCAmelCase ) transformers.utils.logging.enable_default_handler() transformers.utils.logging.enable_explicit_format() # Log on each process the small summary: logger.warning( F"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}" + F"distributed training: {bool(training_args.local_rank != -1 )}, 16-bits training: {training_args.fpaa}" ) logger.info(F"Training/evaluation parameters {training_args}" ) # Detecting last checkpoint. _UpperCAmelCase = None if os.path.isdir(training_args.output_dir ) and training_args.do_train and not training_args.overwrite_output_dir: _UpperCAmelCase = get_last_checkpoint(training_args.output_dir ) if last_checkpoint is None and len(os.listdir(training_args.output_dir ) ) > 0: raise ValueError( F"Output directory ({training_args.output_dir}) already exists and is not empty. " 'Use --overwrite_output_dir to overcome.' ) elif last_checkpoint is not None and training_args.resume_from_checkpoint is None: logger.info( F"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change " 'the `--output_dir` or add `--overwrite_output_dir` to train from scratch.' ) # Set seed before initializing model. set_seed(training_args.seed ) # Get the datasets: you can either provide your own CSV/JSON training and evaluation files (see below) # or specify a GLUE benchmark task (the dataset will be downloaded automatically from the datasets Hub). # # For JSON files, this script will use the `question` column for the input question and `table` column for the corresponding table. # # If the CSVs/JSONs contain only one non-label column, the script does single sentence classification on this # single column. You can easily tweak this behavior (see below) # # In distributed training, the load_dataset function guarantee that only one local process can concurrently # download the dataset. if data_args.dataset_name is not None: # Downloading and loading a dataset from the hub. _UpperCAmelCase = load_dataset( data_args.dataset_name , data_args.dataset_config_name , cache_dir=model_args.cache_dir ) else: # Loading a dataset from your local files. # CSV/JSON training and evaluation files are needed. _UpperCAmelCase = {'train': data_args.train_file, 'validation': data_args.validation_file} # Get the test dataset: you can provide your own CSV/JSON test file (see below) # when you use `do_predict` without specifying a GLUE benchmark task. if training_args.do_predict: if data_args.test_file is not None: _UpperCAmelCase = data_args.train_file.split('.' )[-1] _UpperCAmelCase = data_args.test_file.split('.' )[-1] assert ( test_extension == train_extension ), "`test_file` should have the same extension (csv or json) as `train_file`." _UpperCAmelCase = data_args.test_file else: raise ValueError('Need either a GLUE task or a test file for `do_predict`.' ) for key in data_files.keys(): logger.info(F"load a local file for {key}: {data_files[key]}" ) if data_args.train_file.endswith('.csv' ): # Loading a dataset from local csv files _UpperCAmelCase = load_dataset('csv' , data_files=_UpperCAmelCase , cache_dir=model_args.cache_dir ) else: # Loading a dataset from local json files _UpperCAmelCase = load_dataset('json' , data_files=_UpperCAmelCase , cache_dir=model_args.cache_dir ) # See more about loading any type of standard or custom dataset at # https://huggingface.co/docs/datasets/loading_datasets.html. # Labels _UpperCAmelCase = raw_datasets['train'].features['label'].names _UpperCAmelCase = len(_UpperCAmelCase ) # Load pretrained model and tokenizer # # In distributed training, the .from_pretrained methods guarantee that only one local process can concurrently # download model & vocab. _UpperCAmelCase = AutoConfig.from_pretrained( model_args.config_name if model_args.config_name else model_args.model_name_or_path , num_labels=_UpperCAmelCase , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , ) # load tapex tokenizer _UpperCAmelCase = TapexTokenizer.from_pretrained( model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path , cache_dir=model_args.cache_dir , use_fast=model_args.use_fast_tokenizer , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , add_prefix_space=_UpperCAmelCase , ) _UpperCAmelCase = BartForSequenceClassification.from_pretrained( model_args.model_name_or_path , from_tf=bool('.ckpt' in model_args.model_name_or_path ) , config=_UpperCAmelCase , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , ) # Padding strategy if data_args.pad_to_max_length: _UpperCAmelCase = 'max_length' else: # We will pad later, dynamically at batch creation, to the max sequence length in each batch _UpperCAmelCase = False # Some models have set the order of the labels to use, so let's make sure we do use it. _UpperCAmelCase = {'Refused': 0, 'Entailed': 1} _UpperCAmelCase = {0: 'Refused', 1: 'Entailed'} if data_args.max_seq_length > tokenizer.model_max_length: logger.warning( F"The max_seq_length passed ({data_args.max_seq_length}) is larger than the maximum length for the" F"model ({tokenizer.model_max_length}). Using max_seq_length={tokenizer.model_max_length}." ) _UpperCAmelCase = min(data_args.max_seq_length , tokenizer.model_max_length ) def preprocess_tabfact_function(_UpperCAmelCase : Union[str, Any] ): # Tokenize the texts def _convert_table_text_to_pandas(_UpperCAmelCase : Dict ): _UpperCAmelCase = [_table_row.split('#' ) for _table_row in _table_text.strip('\n' ).split('\n' )] _UpperCAmelCase = pd.DataFrame.from_records(_table_content[1:] , columns=_table_content[0] ) return _table_pd _UpperCAmelCase = examples['statement'] _UpperCAmelCase = list(map(_convert_table_text_to_pandas , examples['table_text'] ) ) _UpperCAmelCase = tokenizer(_UpperCAmelCase , _UpperCAmelCase , padding=_UpperCAmelCase , max_length=_UpperCAmelCase , truncation=_UpperCAmelCase ) _UpperCAmelCase = examples['label'] return result with training_args.main_process_first(desc='dataset map pre-processing' ): _UpperCAmelCase = raw_datasets.map( _UpperCAmelCase , batched=_UpperCAmelCase , load_from_cache_file=not data_args.overwrite_cache , desc='Running tokenizer on dataset' , ) if training_args.do_train: if "train" not in raw_datasets: raise ValueError('--do_train requires a train dataset' ) _UpperCAmelCase = raw_datasets['train'] if data_args.max_train_samples is not None: _UpperCAmelCase = train_dataset.select(range(data_args.max_train_samples ) ) if training_args.do_eval: if "validation" not in raw_datasets and "validation_matched" not in raw_datasets: raise ValueError('--do_eval requires a validation dataset' ) _UpperCAmelCase = raw_datasets['validation'] if data_args.max_eval_samples is not None: _UpperCAmelCase = eval_dataset.select(range(data_args.max_eval_samples ) ) if training_args.do_predict or data_args.test_file is not None: if "test" not in raw_datasets and "test_matched" not in raw_datasets: raise ValueError('--do_predict requires a test dataset' ) _UpperCAmelCase = raw_datasets['test'] if data_args.max_predict_samples is not None: _UpperCAmelCase = predict_dataset.select(range(data_args.max_predict_samples ) ) # Log a few random samples from the training set: if training_args.do_train: for index in random.sample(range(len(_UpperCAmelCase ) ) , 3 ): logger.info(F"Sample {index} of the training set: {train_dataset[index]}." ) # You can define your custom compute_metrics function. It takes an `EvalPrediction` object (a namedtuple with a # predictions and label_ids field) and has to return a dictionary string to float. def compute_metrics(_UpperCAmelCase : EvalPrediction ): _UpperCAmelCase = p.predictions[0] if isinstance(p.predictions , _UpperCAmelCase ) else p.predictions _UpperCAmelCase = np.argmax(_UpperCAmelCase , axis=1 ) return {"accuracy": (preds == p.label_ids).astype(np.floataa ).mean().item()} # Data collator will default to DataCollatorWithPadding, so we change it if we already did the padding. if data_args.pad_to_max_length: _UpperCAmelCase = default_data_collator elif training_args.fpaa: _UpperCAmelCase = DataCollatorWithPadding(_UpperCAmelCase , pad_to_multiple_of=8 ) else: _UpperCAmelCase = None # Initialize our Trainer _UpperCAmelCase = Trainer( model=_UpperCAmelCase , args=_UpperCAmelCase , train_dataset=train_dataset if training_args.do_train else None , eval_dataset=eval_dataset if training_args.do_eval else None , compute_metrics=_UpperCAmelCase , tokenizer=_UpperCAmelCase , data_collator=_UpperCAmelCase , ) # Training if training_args.do_train: _UpperCAmelCase = None if training_args.resume_from_checkpoint is not None: _UpperCAmelCase = training_args.resume_from_checkpoint elif last_checkpoint is not None: _UpperCAmelCase = last_checkpoint _UpperCAmelCase = trainer.train(resume_from_checkpoint=_UpperCAmelCase ) _UpperCAmelCase = train_result.metrics _UpperCAmelCase = ( data_args.max_train_samples if data_args.max_train_samples is not None else len(_UpperCAmelCase ) ) _UpperCAmelCase = min(_UpperCAmelCase , len(_UpperCAmelCase ) ) trainer.save_model() # Saves the tokenizer too for easy upload trainer.log_metrics('train' , _UpperCAmelCase ) trainer.save_metrics('train' , _UpperCAmelCase ) trainer.save_state() # Evaluation if training_args.do_eval: logger.info('*** Evaluate ***' ) _UpperCAmelCase = trainer.evaluate(eval_dataset=_UpperCAmelCase ) _UpperCAmelCase = data_args.max_eval_samples if data_args.max_eval_samples is not None else len(_UpperCAmelCase ) _UpperCAmelCase = min(_UpperCAmelCase , len(_UpperCAmelCase ) ) trainer.log_metrics('eval' , _UpperCAmelCase ) trainer.save_metrics('eval' , _UpperCAmelCase ) if training_args.do_predict: logger.info('*** Predict ***' ) # Removing the `label` columns because it contains -1 and Trainer won't like that. _UpperCAmelCase = predict_dataset.remove_columns('label' ) _UpperCAmelCase = trainer.predict(_UpperCAmelCase , metric_key_prefix='predict' ).predictions _UpperCAmelCase = np.argmax(_UpperCAmelCase , axis=1 ) _UpperCAmelCase = os.path.join(training_args.output_dir , 'predict_results_tabfact.txt' ) if trainer.is_world_process_zero(): with open(_UpperCAmelCase , 'w' ) as writer: logger.info('***** Predict Results *****' ) writer.write('index\tprediction\n' ) for index, item in enumerate(_UpperCAmelCase ): _UpperCAmelCase = label_list[item] writer.write(F"{index}\t{item}\n" ) _UpperCAmelCase = {'finetuned_from': model_args.model_name_or_path, 'tasks': 'text-classification'} if training_args.push_to_hub: trainer.push_to_hub(**_UpperCAmelCase ) else: trainer.create_model_card(**_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[Any] ) -> Optional[Any]: '''simple docstring''' # For xla_spawn (TPUs) main() if __name__ == "__main__": main()
339
1
import unittest from pathlib import Path from tempfile import TemporaryDirectory from transformers import AutoConfig, TFAutoModel, is_tensorflow_text_available, is_tf_available from transformers.models.bert.tokenization_bert import BertTokenizer from transformers.testing_utils import require_tensorflow_text, require_tf, slow if is_tf_available(): import tensorflow as tf if is_tensorflow_text_available(): from transformers.models.bert import TFBertTokenizer UpperCAmelCase__ = ["bert-base-uncased", "bert-base-cased"] UpperCAmelCase__ = "hf-internal-testing/tiny-bert-tf-only" if is_tf_available(): class __lowerCAmelCase ( tf.keras.Model ): def __init__( self : str , A : str) -> Tuple: """simple docstring""" super().__init__() _UpperCAmelCase = tokenizer _UpperCAmelCase = AutoConfig.from_pretrained(A) _UpperCAmelCase = TFAutoModel.from_config(A) def _lowerCamelCase ( self : int , A : int) -> Tuple: """simple docstring""" _UpperCAmelCase = self.tokenizer(A) _UpperCAmelCase = self.bert(**A) return out["pooler_output"] @require_tf @require_tensorflow_text class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Tuple) -> Optional[int]: """simple docstring""" super().setUp() _UpperCAmelCase = [ BertTokenizer.from_pretrained(A) for checkpoint in (TOKENIZER_CHECKPOINTS * 2) ] # repeat for when fast_bert_tokenizer=false _UpperCAmelCase = [TFBertTokenizer.from_pretrained(A) for checkpoint in TOKENIZER_CHECKPOINTS] + [ TFBertTokenizer.from_pretrained(A , use_fast_bert_tokenizer=A) for checkpoint in TOKENIZER_CHECKPOINTS ] assert len(self.tokenizers) == len(self.tf_tokenizers) _UpperCAmelCase = [ 'This is a straightforward English test sentence.', 'This one has some weird characters\rto\nsee\r\nif those\u00E9break things.', 'Now we\'re going to add some Chinese: 一 二 三 一二三', 'And some much more rare Chinese: 齉 堃 齉堃', 'Je vais aussi écrire en français pour tester les accents', 'Classical Irish also has some unusual characters, so in they go: Gaelaċ, ꝼ', ] _UpperCAmelCase = list(zip(self.test_sentences , self.test_sentences[::-1])) def _lowerCamelCase ( self : List[Any]) -> Union[str, Any]: """simple docstring""" for tokenizer, tf_tokenizer in zip(self.tokenizers , self.tf_tokenizers): for test_inputs in (self.test_sentences, self.paired_sentences): _UpperCAmelCase = tokenizer(A , return_tensors='tf' , padding='longest') _UpperCAmelCase = tf_tokenizer(A) for key in python_outputs.keys(): self.assertTrue(tf.reduce_all(python_outputs[key].shape == tf_outputs[key].shape)) self.assertTrue(tf.reduce_all(tf.cast(python_outputs[key] , tf.intaa) == tf_outputs[key])) @slow def _lowerCamelCase ( self : List[Any]) -> Any: """simple docstring""" for tf_tokenizer in self.tf_tokenizers: _UpperCAmelCase = tf_tokenizer(self.paired_sentences) _UpperCAmelCase = tf_tokenizer( text=[sentence[0] for sentence in self.paired_sentences] , text_pair=[sentence[1] for sentence in self.paired_sentences] , ) for key in merged_outputs.keys(): self.assertTrue(tf.reduce_all(tf.cast(merged_outputs[key] , tf.intaa) == separated_outputs[key])) @slow def _lowerCamelCase ( self : List[str]) -> str: """simple docstring""" for tf_tokenizer in self.tf_tokenizers: _UpperCAmelCase = tf.function(A) for test_inputs in (self.test_sentences, self.paired_sentences): _UpperCAmelCase = tf.constant(A) _UpperCAmelCase = compiled_tokenizer(A) _UpperCAmelCase = tf_tokenizer(A) for key in eager_outputs.keys(): self.assertTrue(tf.reduce_all(eager_outputs[key] == compiled_outputs[key])) @slow def _lowerCamelCase ( self : Optional[Any]) -> Dict: """simple docstring""" for tf_tokenizer in self.tf_tokenizers: _UpperCAmelCase = ModelToSave(tokenizer=A) _UpperCAmelCase = tf.convert_to_tensor(self.test_sentences) _UpperCAmelCase = model(A) # Build model with some sample inputs with TemporaryDirectory() as tempdir: _UpperCAmelCase = Path(A) / 'saved.model' model.save(A) _UpperCAmelCase = tf.keras.models.load_model(A) _UpperCAmelCase = loaded_model(A) # We may see small differences because the loaded model is compiled, so we need an epsilon for the test self.assertLessEqual(tf.reduce_max(tf.abs(out - loaded_output)) , 1E-5)
339
# This code is adapted from OpenAI's release # https://github.com/openai/human-eval/blob/master/human_eval/execution.py import contextlib import faulthandler import io import multiprocessing import os import platform import signal import tempfile def A ( _UpperCAmelCase : Union[str, Any] , _UpperCAmelCase : Dict , _UpperCAmelCase : Dict , _UpperCAmelCase : Dict ) -> Any: '''simple docstring''' _UpperCAmelCase = multiprocessing.Manager() _UpperCAmelCase = manager.list() _UpperCAmelCase = multiprocessing.Process(target=_UpperCAmelCase , args=(check_program, result, timeout) ) p.start() p.join(timeout=timeout + 1 ) if p.is_alive(): p.kill() if not result: result.append('timed out' ) return { "task_id": task_id, "passed": result[0] == "passed", "result": result[0], "completion_id": completion_id, } def A ( _UpperCAmelCase : str , _UpperCAmelCase : List[str] , _UpperCAmelCase : Dict ) -> Optional[int]: '''simple docstring''' with create_tempdir(): # These system calls are needed when cleaning up tempdir. import os import shutil _UpperCAmelCase = shutil.rmtree _UpperCAmelCase = os.rmdir _UpperCAmelCase = os.chdir # Disable functionalities that can make destructive changes to the test. reliability_guard() # Run program. try: _UpperCAmelCase = {} with swallow_io(): with time_limit(_UpperCAmelCase ): exec(_UpperCAmelCase , _UpperCAmelCase ) result.append('passed' ) except TimeoutException: result.append('timed out' ) except BaseException as e: result.append(F"failed: {e}" ) # Needed for cleaning up. _UpperCAmelCase = rmtree _UpperCAmelCase = rmdir _UpperCAmelCase = chdir @contextlib.contextmanager def A ( _UpperCAmelCase : Union[str, Any] ) -> Any: '''simple docstring''' def signal_handler(_UpperCAmelCase : List[Any] , _UpperCAmelCase : Dict ): raise TimeoutException('Timed out!' ) signal.setitimer(signal.ITIMER_REAL , _UpperCAmelCase ) signal.signal(signal.SIGALRM , _UpperCAmelCase ) try: yield finally: signal.setitimer(signal.ITIMER_REAL , 0 ) @contextlib.contextmanager def A ( ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = WriteOnlyStringIO() with contextlib.redirect_stdout(_UpperCAmelCase ): with contextlib.redirect_stderr(_UpperCAmelCase ): with redirect_stdin(_UpperCAmelCase ): yield @contextlib.contextmanager def A ( ) -> Any: '''simple docstring''' with tempfile.TemporaryDirectory() as dirname: with chdir(_UpperCAmelCase ): yield dirname class __lowerCAmelCase ( A ): pass class __lowerCAmelCase ( io.StringIO ): def _lowerCamelCase ( self : Tuple , *A : str , **A : Any) -> Any: """simple docstring""" raise OSError def _lowerCamelCase ( self : List[str] , *A : Optional[Any] , **A : Optional[Any]) -> Optional[int]: """simple docstring""" raise OSError def _lowerCamelCase ( self : str , *A : List[str] , **A : List[Any]) -> Union[str, Any]: """simple docstring""" raise OSError def _lowerCamelCase ( self : Union[str, Any] , *A : Optional[Any] , **A : List[str]) -> Optional[int]: """simple docstring""" return False class __lowerCAmelCase ( contextlib._RedirectStream ): # type: ignore UpperCamelCase = '''stdin''' @contextlib.contextmanager def A ( _UpperCAmelCase : List[Any] ) -> Dict: '''simple docstring''' if root == ".": yield return _UpperCAmelCase = os.getcwd() os.chdir(_UpperCAmelCase ) try: yield except BaseException as exc: raise exc finally: os.chdir(_UpperCAmelCase ) def A ( _UpperCAmelCase : List[str]=None ) -> Any: '''simple docstring''' if maximum_memory_bytes is not None: import resource resource.setrlimit(resource.RLIMIT_AS , (maximum_memory_bytes, maximum_memory_bytes) ) resource.setrlimit(resource.RLIMIT_DATA , (maximum_memory_bytes, maximum_memory_bytes) ) if not platform.uname().system == "Darwin": resource.setrlimit(resource.RLIMIT_STACK , (maximum_memory_bytes, maximum_memory_bytes) ) faulthandler.disable() import builtins _UpperCAmelCase = None _UpperCAmelCase = None import os _UpperCAmelCase = '1' _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None import shutil _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None import subprocess _UpperCAmelCase = None # type: ignore _UpperCAmelCase = None import sys _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None
339
1
from dataclasses import asdict, dataclass from typing import Optional from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCAmelCase__ = logging.get_logger(__name__) # TODO Update this UpperCAmelCase__ = { "facebook/esm-1b": "https://huggingface.co/facebook/esm-1b/resolve/main/config.json", # See all ESM models at https://huggingface.co/models?filter=esm } class __lowerCAmelCase ( A ): UpperCamelCase = '''esm''' def __init__( self : Dict , A : int=None , A : Tuple=None , A : str=None , A : Dict=7_68 , A : Optional[int]=12 , A : Tuple=12 , A : List[str]=30_72 , A : int=0.1 , A : Dict=0.1 , A : Dict=10_26 , A : Any=0.0_2 , A : int=1E-12 , A : Any="absolute" , A : Any=True , A : Any=None , A : Optional[int]=False , A : Optional[int]=False , A : Tuple=None , A : Union[str, Any]=None , **A : Any , ) -> Dict: """simple docstring""" super().__init__(pad_token_id=A , mask_token_id=A , **A) _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = initializer_range _UpperCAmelCase = layer_norm_eps _UpperCAmelCase = position_embedding_type _UpperCAmelCase = use_cache _UpperCAmelCase = emb_layer_norm_before _UpperCAmelCase = token_dropout _UpperCAmelCase = is_folding_model if is_folding_model: if esmfold_config is None: logger.info('No esmfold_config supplied for folding model, using default values.') _UpperCAmelCase = EsmFoldConfig() elif isinstance(A , A): _UpperCAmelCase = EsmFoldConfig(**A) _UpperCAmelCase = esmfold_config if vocab_list is None: logger.warning('No vocab_list supplied for folding model, assuming the ESM-2 vocabulary!') _UpperCAmelCase = get_default_vocab_list() else: _UpperCAmelCase = vocab_list else: _UpperCAmelCase = None _UpperCAmelCase = None if self.esmfold_config is not None and getattr(self.esmfold_config , 'use_esm_attn_map' , A): raise ValueError('The HuggingFace port of ESMFold does not support use_esm_attn_map at this time!') def _lowerCamelCase ( self : Optional[Any]) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = super().to_dict() if isinstance(self.esmfold_config , A): _UpperCAmelCase = self.esmfold_config.to_dict() return output @dataclass class __lowerCAmelCase : UpperCamelCase = None UpperCamelCase = True UpperCamelCase = False UpperCamelCase = False UpperCamelCase = False UpperCamelCase = 0 UpperCamelCase = True UpperCamelCase = False UpperCamelCase = 1_2_8 UpperCamelCase = None def _lowerCamelCase ( self : Optional[Any]) -> List[str]: """simple docstring""" if self.trunk is None: _UpperCAmelCase = TrunkConfig() elif isinstance(self.trunk , A): _UpperCAmelCase = TrunkConfig(**self.trunk) def _lowerCamelCase ( self : Union[str, Any]) -> List[str]: """simple docstring""" _UpperCAmelCase = asdict(self) _UpperCAmelCase = self.trunk.to_dict() return output @dataclass class __lowerCAmelCase : UpperCamelCase = 4_8 UpperCamelCase = 1_0_2_4 UpperCamelCase = 1_2_8 UpperCamelCase = 3_2 UpperCamelCase = 3_2 UpperCamelCase = 3_2 UpperCamelCase = 0 UpperCamelCase = 0 UpperCamelCase = False UpperCamelCase = 4 UpperCamelCase = 1_2_8 UpperCamelCase = None def _lowerCamelCase ( self : str) -> List[str]: """simple docstring""" if self.structure_module is None: _UpperCAmelCase = StructureModuleConfig() elif isinstance(self.structure_module , A): _UpperCAmelCase = StructureModuleConfig(**self.structure_module) if self.max_recycles <= 0: raise ValueError(F"`max_recycles` should be positive, got {self.max_recycles}.") if self.sequence_state_dim % self.sequence_state_dim != 0: raise ValueError( '`sequence_state_dim` should be a round multiple of `sequence_state_dim`, got' F" {self.sequence_state_dim} and {self.sequence_state_dim}.") if self.pairwise_state_dim % self.pairwise_state_dim != 0: raise ValueError( '`pairwise_state_dim` should be a round multiple of `pairwise_state_dim`, got' F" {self.pairwise_state_dim} and {self.pairwise_state_dim}.") _UpperCAmelCase = self.sequence_state_dim // self.sequence_head_width _UpperCAmelCase = self.pairwise_state_dim // self.pairwise_head_width if self.sequence_state_dim != sequence_num_heads * self.sequence_head_width: raise ValueError( '`sequence_state_dim` should be equal to `sequence_num_heads * sequence_head_width, got' F" {self.sequence_state_dim} != {sequence_num_heads} * {self.sequence_head_width}.") if self.pairwise_state_dim != pairwise_num_heads * self.pairwise_head_width: raise ValueError( '`pairwise_state_dim` should be equal to `pairwise_num_heads * pairwise_head_width, got' F" {self.pairwise_state_dim} != {pairwise_num_heads} * {self.pairwise_head_width}.") if self.pairwise_state_dim % 2 != 0: raise ValueError(F"`pairwise_state_dim` should be even, got {self.pairwise_state_dim}.") if self.dropout >= 0.4: raise ValueError(F"`dropout` should not be greater than 0.4, got {self.dropout}.") def _lowerCamelCase ( self : int) -> int: """simple docstring""" _UpperCAmelCase = asdict(self) _UpperCAmelCase = self.structure_module.to_dict() return output @dataclass class __lowerCAmelCase : UpperCamelCase = 3_8_4 UpperCamelCase = 1_2_8 UpperCamelCase = 1_6 UpperCamelCase = 1_2_8 UpperCamelCase = 1_2 UpperCamelCase = 4 UpperCamelCase = 8 UpperCamelCase = 0.1 UpperCamelCase = 8 UpperCamelCase = 1 UpperCamelCase = 2 UpperCamelCase = 7 UpperCamelCase = 1_0 UpperCamelCase = 1e-8 UpperCamelCase = 1e5 def _lowerCamelCase ( self : Dict) -> List[str]: """simple docstring""" return asdict(self) def A ( ) -> List[Any]: '''simple docstring''' return ( "<cls>", "<pad>", "<eos>", "<unk>", "L", "A", "G", "V", "S", "E", "R", "T", "I", "D", "P", "K", "Q", "N", "F", "Y", "M", "H", "W", "C", "X", "B", "U", "Z", "O", ".", "-", "<null_1>", "<mask>", )
339
import asyncio import os import shutil import subprocess import sys import tempfile import unittest from distutils.util import strtobool from functools import partial from pathlib import Path from typing import List, Union from unittest import mock import torch from ..state import AcceleratorState, PartialState from ..utils import ( gather, is_bnb_available, is_comet_ml_available, is_datasets_available, is_deepspeed_available, is_mps_available, is_safetensors_available, is_tensorboard_available, is_torch_version, is_tpu_available, is_transformers_available, is_wandb_available, is_xpu_available, ) def A ( _UpperCAmelCase : Tuple , _UpperCAmelCase : Union[str, Any]=False ) -> str: '''simple docstring''' try: _UpperCAmelCase = os.environ[key] except KeyError: # KEY isn't set, default to `default`. _UpperCAmelCase = default else: # KEY is set, convert it to True or False. try: _UpperCAmelCase = strtobool(_UpperCAmelCase ) except ValueError: # More values are supported, but let's keep the message simple. raise ValueError(F"If set, {key} must be yes or no." ) return _value UpperCAmelCase__ = parse_flag_from_env("RUN_SLOW", default=False) def A ( _UpperCAmelCase : List[str] ) -> List[str]: '''simple docstring''' return unittest.skip('Test was skipped' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Dict ) -> str: '''simple docstring''' return unittest.skipUnless(_run_slow_tests , 'test is slow' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Any ) -> str: '''simple docstring''' return unittest.skipUnless(not torch.cuda.is_available() , 'test requires only a CPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Dict ) -> Dict: '''simple docstring''' return unittest.skipUnless(torch.cuda.is_available() , 'test requires a GPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[Any] ) -> List[Any]: '''simple docstring''' return unittest.skipUnless(is_xpu_available() , 'test requires a XPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[int] ) -> List[str]: '''simple docstring''' return unittest.skipUnless(is_mps_available() , 'test requires a `mps` backend support in `torch`' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Union[str, Any] ) -> List[Any]: '''simple docstring''' return unittest.skipUnless( is_transformers_available() and is_datasets_available() , 'test requires the Hugging Face suite' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : str ) -> str: '''simple docstring''' return unittest.skipUnless(is_bnb_available() , 'test requires the bitsandbytes library' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Union[str, Any] ) -> List[Any]: '''simple docstring''' return unittest.skipUnless(is_tpu_available() , 'test requires TPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[Any] ) -> str: '''simple docstring''' return unittest.skipUnless(torch.cuda.device_count() == 1 , 'test requires a GPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Tuple ) -> int: '''simple docstring''' return unittest.skipUnless(torch.xpu.device_count() == 1 , 'test requires a XPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Any ) -> Optional[int]: '''simple docstring''' return unittest.skipUnless(torch.cuda.device_count() > 1 , 'test requires multiple GPUs' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Tuple ) -> Any: '''simple docstring''' return unittest.skipUnless(torch.xpu.device_count() > 1 , 'test requires multiple XPUs' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Any ) -> Optional[int]: '''simple docstring''' return unittest.skipUnless(is_safetensors_available() , 'test requires safetensors' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : List[Any] ) -> Dict: '''simple docstring''' return unittest.skipUnless(is_deepspeed_available() , 'test requires DeepSpeed' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[int] ) -> str: '''simple docstring''' return unittest.skipUnless(is_torch_version('>=' , '1.12.0' ) , 'test requires torch version >= 1.12.0' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Any=None , _UpperCAmelCase : List[Any]=None ) -> Dict: '''simple docstring''' if test_case is None: return partial(_UpperCAmelCase , version=_UpperCAmelCase ) return unittest.skipUnless(is_torch_version('>=' , _UpperCAmelCase ) , F"test requires torch version >= {version}" )(_UpperCAmelCase ) def A ( _UpperCAmelCase : List[str] ) -> int: '''simple docstring''' return unittest.skipUnless(is_tensorboard_available() , 'test requires Tensorboard' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Union[str, Any] ) -> Union[str, Any]: '''simple docstring''' return unittest.skipUnless(is_wandb_available() , 'test requires wandb' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : List[str] ) -> Optional[int]: '''simple docstring''' return unittest.skipUnless(is_comet_ml_available() , 'test requires comet_ml' )(_UpperCAmelCase ) UpperCAmelCase__ = ( any([is_wandb_available(), is_tensorboard_available()]) and not is_comet_ml_available() ) def A ( _UpperCAmelCase : List[str] ) -> Any: '''simple docstring''' return unittest.skipUnless( _atleast_one_tracker_available , 'test requires at least one tracker to be available and for `comet_ml` to not be installed' , )(_UpperCAmelCase ) class __lowerCAmelCase ( unittest.TestCase ): UpperCamelCase = True @classmethod def _lowerCamelCase ( cls : List[Any]) -> Tuple: """simple docstring""" _UpperCAmelCase = tempfile.mkdtemp() @classmethod def _lowerCamelCase ( cls : Union[str, Any]) -> str: """simple docstring""" if os.path.exists(cls.tmpdir): shutil.rmtree(cls.tmpdir) def _lowerCamelCase ( self : List[str]) -> List[Any]: """simple docstring""" if self.clear_on_setup: for path in Path(self.tmpdir).glob('**/*'): if path.is_file(): path.unlink() elif path.is_dir(): shutil.rmtree(A) class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Dict) -> Tuple: """simple docstring""" super().tearDown() # Reset the state of the AcceleratorState singleton. AcceleratorState._reset_state() PartialState._reset_state() class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Optional[int] , A : Union[mock.Mock, List[mock.Mock]]) -> Tuple: """simple docstring""" _UpperCAmelCase = mocks if isinstance(A , (tuple, list)) else [mocks] for m in self.mocks: m.start() self.addCleanup(m.stop) def A ( _UpperCAmelCase : List[Any] ) -> int: '''simple docstring''' _UpperCAmelCase = AcceleratorState() _UpperCAmelCase = tensor[None].clone().to(state.device ) _UpperCAmelCase = gather(_UpperCAmelCase ).cpu() _UpperCAmelCase = tensor[0].cpu() for i in range(tensors.shape[0] ): if not torch.equal(tensors[i] , _UpperCAmelCase ): return False return True class __lowerCAmelCase : def __init__( self : Optional[Any] , A : Union[str, Any] , A : Optional[int] , A : str) -> Optional[int]: """simple docstring""" _UpperCAmelCase = returncode _UpperCAmelCase = stdout _UpperCAmelCase = stderr async def A ( _UpperCAmelCase : str , _UpperCAmelCase : Optional[int] ) -> Optional[Any]: '''simple docstring''' while True: _UpperCAmelCase = await stream.readline() if line: callback(_UpperCAmelCase ) else: break async def A ( _UpperCAmelCase : Optional[int] , _UpperCAmelCase : List[str]=None , _UpperCAmelCase : str=None , _UpperCAmelCase : str=None , _UpperCAmelCase : Dict=False , _UpperCAmelCase : Union[str, Any]=False ) -> _RunOutput: '''simple docstring''' if echo: print('\nRunning: ' , ' '.join(_UpperCAmelCase ) ) _UpperCAmelCase = await asyncio.create_subprocess_exec( cmd[0] , *cmd[1:] , stdin=_UpperCAmelCase , stdout=asyncio.subprocess.PIPE , stderr=asyncio.subprocess.PIPE , env=_UpperCAmelCase , ) # note: there is a warning for a possible deadlock when using `wait` with huge amounts of data in the pipe # https://docs.python.org/3/library/asyncio-subprocess.html#asyncio.asyncio.subprocess.Process.wait # # If it starts hanging, will need to switch to the following code. The problem is that no data # will be seen until it's done and if it hangs for example there will be no debug info. # out, err = await p.communicate() # return _RunOutput(p.returncode, out, err) _UpperCAmelCase = [] _UpperCAmelCase = [] def tee(_UpperCAmelCase : Union[str, Any] , _UpperCAmelCase : List[Any] , _UpperCAmelCase : str , _UpperCAmelCase : str="" ): _UpperCAmelCase = line.decode('utf-8' ).rstrip() sink.append(_UpperCAmelCase ) if not quiet: print(_UpperCAmelCase , _UpperCAmelCase , file=_UpperCAmelCase ) # XXX: the timeout doesn't seem to make any difference here await asyncio.wait( [ asyncio.create_task(_read_stream(p.stdout , lambda _UpperCAmelCase : tee(_UpperCAmelCase , _UpperCAmelCase , sys.stdout , label='stdout:' ) ) ), asyncio.create_task(_read_stream(p.stderr , lambda _UpperCAmelCase : tee(_UpperCAmelCase , _UpperCAmelCase , sys.stderr , label='stderr:' ) ) ), ] , timeout=_UpperCAmelCase , ) return _RunOutput(await p.wait() , _UpperCAmelCase , _UpperCAmelCase ) def A ( _UpperCAmelCase : str , _UpperCAmelCase : Dict=None , _UpperCAmelCase : str=None , _UpperCAmelCase : str=180 , _UpperCAmelCase : List[Any]=False , _UpperCAmelCase : List[Any]=True ) -> _RunOutput: '''simple docstring''' _UpperCAmelCase = asyncio.get_event_loop() _UpperCAmelCase = loop.run_until_complete( _stream_subprocess(_UpperCAmelCase , env=_UpperCAmelCase , stdin=_UpperCAmelCase , timeout=_UpperCAmelCase , quiet=_UpperCAmelCase , echo=_UpperCAmelCase ) ) _UpperCAmelCase = ' '.join(_UpperCAmelCase ) if result.returncode > 0: _UpperCAmelCase = '\n'.join(result.stderr ) raise RuntimeError( F"'{cmd_str}' failed with returncode {result.returncode}\n\n" F"The combined stderr from workers follows:\n{stderr}" ) return result class __lowerCAmelCase ( A ): pass def A ( _UpperCAmelCase : List[str] , _UpperCAmelCase : str=False ) -> Tuple: '''simple docstring''' try: _UpperCAmelCase = subprocess.check_output(_UpperCAmelCase , stderr=subprocess.STDOUT ) if return_stdout: if hasattr(_UpperCAmelCase , 'decode' ): _UpperCAmelCase = output.decode('utf-8' ) return output except subprocess.CalledProcessError as e: raise SubprocessCallException( F"Command `{' '.join(_UpperCAmelCase )}` failed with the following error:\n\n{e.output.decode()}" ) from e
339
1
import unittest import numpy as np from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available from ...test_image_processing_common import ImageProcessingSavingTestMixin if is_torch_available(): import torch if is_vision_available(): from PIL import Image from transformers import ChineseCLIPImageProcessor class __lowerCAmelCase ( unittest.TestCase ): def __init__( self : Any , A : str , A : Dict=7 , A : Dict=3 , A : List[str]=18 , A : int=30 , A : Any=4_00 , A : Union[str, Any]=True , A : List[str]=None , A : Dict=True , A : str=None , A : Dict=True , A : Optional[Any]=[0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3] , A : Optional[Any]=[0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1] , A : str=True , ) -> List[Any]: """simple docstring""" _UpperCAmelCase = size if size is not None else {'height': 2_24, 'width': 2_24} _UpperCAmelCase = crop_size if crop_size is not None else {'height': 18, 'width': 18} _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = num_channels _UpperCAmelCase = image_size _UpperCAmelCase = min_resolution _UpperCAmelCase = max_resolution _UpperCAmelCase = do_resize _UpperCAmelCase = size _UpperCAmelCase = do_center_crop _UpperCAmelCase = crop_size _UpperCAmelCase = do_normalize _UpperCAmelCase = image_mean _UpperCAmelCase = image_std _UpperCAmelCase = do_convert_rgb def _lowerCamelCase ( self : Optional[int]) -> List[Any]: """simple docstring""" return { "do_resize": self.do_resize, "size": self.size, "do_center_crop": self.do_center_crop, "crop_size": self.crop_size, "do_normalize": self.do_normalize, "image_mean": self.image_mean, "image_std": self.image_std, "do_convert_rgb": self.do_convert_rgb, } def _lowerCamelCase ( self : List[str] , A : List[Any]=False , A : Union[str, Any]=False , A : List[Any]=False) -> str: """simple docstring""" assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time" if equal_resolution: _UpperCAmelCase = [] for i in range(self.batch_size): image_inputs.append( np.random.randint( 2_55 , size=(self.num_channels, self.max_resolution, self.max_resolution) , dtype=np.uinta)) else: _UpperCAmelCase = [] for i in range(self.batch_size): _UpperCAmelCase , _UpperCAmelCase = np.random.choice(np.arange(self.min_resolution , self.max_resolution) , 2) image_inputs.append(np.random.randint(2_55 , size=(self.num_channels, width, height) , dtype=np.uinta)) if not numpify and not torchify: # PIL expects the channel dimension as last dimension _UpperCAmelCase = [Image.fromarray(np.moveaxis(A , 0 , -1)) for x in image_inputs] if torchify: _UpperCAmelCase = [torch.from_numpy(A) for x in image_inputs] return image_inputs @require_torch @require_vision class __lowerCAmelCase ( A , unittest.TestCase ): UpperCamelCase = ChineseCLIPImageProcessor if is_vision_available() else None def _lowerCamelCase ( self : Optional[int]) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = ChineseCLIPImageProcessingTester(self , do_center_crop=A) @property def _lowerCamelCase ( self : List[str]) -> Any: """simple docstring""" return self.image_processor_tester.prepare_image_processor_dict() def _lowerCamelCase ( self : Any) -> str: """simple docstring""" _UpperCAmelCase = self.image_processing_class(**self.image_processor_dict) self.assertTrue(hasattr(A , 'do_resize')) self.assertTrue(hasattr(A , 'size')) self.assertTrue(hasattr(A , 'do_center_crop')) self.assertTrue(hasattr(A , 'center_crop')) self.assertTrue(hasattr(A , 'do_normalize')) self.assertTrue(hasattr(A , 'image_mean')) self.assertTrue(hasattr(A , 'image_std')) self.assertTrue(hasattr(A , 'do_convert_rgb')) def _lowerCamelCase ( self : str) -> Dict: """simple docstring""" _UpperCAmelCase = self.image_processing_class.from_dict(self.image_processor_dict) self.assertEqual(image_processor.size , {'height': 2_24, 'width': 2_24}) self.assertEqual(image_processor.crop_size , {'height': 18, 'width': 18}) _UpperCAmelCase = self.image_processing_class.from_dict(self.image_processor_dict , size=42 , crop_size=84) self.assertEqual(image_processor.size , {'shortest_edge': 42}) self.assertEqual(image_processor.crop_size , {'height': 84, 'width': 84}) def _lowerCamelCase ( self : List[Any]) -> Any: """simple docstring""" pass def _lowerCamelCase ( self : Tuple) -> List[str]: """simple docstring""" _UpperCAmelCase = self.image_processing_class(**self.image_processor_dict) # create random PIL images _UpperCAmelCase = self.image_processor_tester.prepare_inputs(equal_resolution=A) for image in image_inputs: self.assertIsInstance(A , Image.Image) # Test not batched input _UpperCAmelCase = image_processing(image_inputs[0] , return_tensors='pt').pixel_values self.assertEqual( encoded_images.shape , ( 1, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size['height'], self.image_processor_tester.crop_size['width'], ) , ) # Test batched _UpperCAmelCase = image_processing(A , return_tensors='pt').pixel_values self.assertEqual( encoded_images.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size['height'], self.image_processor_tester.crop_size['width'], ) , ) def _lowerCamelCase ( self : Optional[Any]) -> List[Any]: """simple docstring""" _UpperCAmelCase = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors _UpperCAmelCase = self.image_processor_tester.prepare_inputs(equal_resolution=A , numpify=A) for image in image_inputs: self.assertIsInstance(A , np.ndarray) # Test not batched input _UpperCAmelCase = image_processing(image_inputs[0] , return_tensors='pt').pixel_values self.assertEqual( encoded_images.shape , ( 1, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size['height'], self.image_processor_tester.crop_size['width'], ) , ) # Test batched _UpperCAmelCase = image_processing(A , return_tensors='pt').pixel_values self.assertEqual( encoded_images.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size['height'], self.image_processor_tester.crop_size['width'], ) , ) def _lowerCamelCase ( self : int) -> Dict: """simple docstring""" _UpperCAmelCase = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors _UpperCAmelCase = self.image_processor_tester.prepare_inputs(equal_resolution=A , torchify=A) for image in image_inputs: self.assertIsInstance(A , torch.Tensor) # Test not batched input _UpperCAmelCase = image_processing(image_inputs[0] , return_tensors='pt').pixel_values self.assertEqual( encoded_images.shape , ( 1, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size['height'], self.image_processor_tester.crop_size['width'], ) , ) # Test batched _UpperCAmelCase = image_processing(A , return_tensors='pt').pixel_values self.assertEqual( encoded_images.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size['height'], self.image_processor_tester.crop_size['width'], ) , ) @require_torch @require_vision class __lowerCAmelCase ( A , unittest.TestCase ): UpperCamelCase = ChineseCLIPImageProcessor if is_vision_available() else None def _lowerCamelCase ( self : List[str]) -> str: """simple docstring""" _UpperCAmelCase = ChineseCLIPImageProcessingTester(self , num_channels=4 , do_center_crop=A) _UpperCAmelCase = 3 @property def _lowerCamelCase ( self : Optional[Any]) -> Optional[int]: """simple docstring""" return self.image_processor_tester.prepare_image_processor_dict() def _lowerCamelCase ( self : Optional[int]) -> List[str]: """simple docstring""" _UpperCAmelCase = self.image_processing_class(**self.image_processor_dict) self.assertTrue(hasattr(A , 'do_resize')) self.assertTrue(hasattr(A , 'size')) self.assertTrue(hasattr(A , 'do_center_crop')) self.assertTrue(hasattr(A , 'center_crop')) self.assertTrue(hasattr(A , 'do_normalize')) self.assertTrue(hasattr(A , 'image_mean')) self.assertTrue(hasattr(A , 'image_std')) self.assertTrue(hasattr(A , 'do_convert_rgb')) def _lowerCamelCase ( self : Any) -> Union[str, Any]: """simple docstring""" pass def _lowerCamelCase ( self : Any) -> Optional[int]: """simple docstring""" _UpperCAmelCase = self.image_processing_class(**self.image_processor_dict) # create random PIL images _UpperCAmelCase = self.image_processor_tester.prepare_inputs(equal_resolution=A) for image in image_inputs: self.assertIsInstance(A , Image.Image) # Test not batched input _UpperCAmelCase = image_processing(image_inputs[0] , return_tensors='pt').pixel_values self.assertEqual( encoded_images.shape , ( 1, self.expected_encoded_image_num_channels, self.image_processor_tester.crop_size['height'], self.image_processor_tester.crop_size['width'], ) , ) # Test batched _UpperCAmelCase = image_processing(A , return_tensors='pt').pixel_values self.assertEqual( encoded_images.shape , ( self.image_processor_tester.batch_size, self.expected_encoded_image_num_channels, self.image_processor_tester.crop_size['height'], self.image_processor_tester.crop_size['width'], ) , )
339
from __future__ import annotations UpperCAmelCase__ = list[list[int]] # assigning initial values to the grid UpperCAmelCase__ = [ [3, 0, 6, 5, 0, 8, 4, 0, 0], [5, 2, 0, 0, 0, 0, 0, 0, 0], [0, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] # a grid with no solution UpperCAmelCase__ = [ [5, 0, 6, 5, 0, 8, 4, 0, 3], [5, 2, 0, 0, 0, 0, 0, 0, 2], [1, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] def A ( _UpperCAmelCase : Matrix , _UpperCAmelCase : int , _UpperCAmelCase : int , _UpperCAmelCase : int ) -> bool: '''simple docstring''' for i in range(9 ): if grid[row][i] == n or grid[i][column] == n: return False for i in range(3 ): for j in range(3 ): if grid[(row - row % 3) + i][(column - column % 3) + j] == n: return False return True def A ( _UpperCAmelCase : Matrix ) -> tuple[int, int] | None: '''simple docstring''' for i in range(9 ): for j in range(9 ): if grid[i][j] == 0: return i, j return None def A ( _UpperCAmelCase : Matrix ) -> Matrix | None: '''simple docstring''' if location := find_empty_location(_UpperCAmelCase ): _UpperCAmelCase , _UpperCAmelCase = location else: # If the location is ``None``, then the grid is solved. return grid for digit in range(1 , 10 ): if is_safe(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ): _UpperCAmelCase = digit if sudoku(_UpperCAmelCase ) is not None: return grid _UpperCAmelCase = 0 return None def A ( _UpperCAmelCase : Matrix ) -> None: '''simple docstring''' for row in grid: for cell in row: print(_UpperCAmelCase , end=' ' ) print() if __name__ == "__main__": # make a copy of grid so that you can compare with the unmodified grid for example_grid in (initial_grid, no_solution): print("\nExample grid:\n" + "=" * 20) print_solution(example_grid) print("\nExample grid solution:") UpperCAmelCase__ = sudoku(example_grid) if solution is not None: print_solution(solution) else: print("Cannot find a solution.")
339
1
import json import pathlib import unittest import numpy as np from transformers.testing_utils import require_torch, require_vision, slow from transformers.utils import is_torch_available, is_vision_available from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): import torch if is_vision_available(): from PIL import Image from transformers import DetaImageProcessor class __lowerCAmelCase ( unittest.TestCase ): def __init__( self : Tuple , A : Any , A : int=7 , A : str=3 , A : Optional[int]=30 , A : Union[str, Any]=4_00 , A : Tuple=True , A : Optional[Any]=None , A : Union[str, Any]=True , A : Optional[Any]=[0.5, 0.5, 0.5] , A : Optional[int]=[0.5, 0.5, 0.5] , A : str=True , A : List[str]=1 / 2_55 , A : List[str]=True , ) -> Any: """simple docstring""" _UpperCAmelCase = size if size is not None else {'shortest_edge': 18, 'longest_edge': 13_33} _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = num_channels _UpperCAmelCase = min_resolution _UpperCAmelCase = max_resolution _UpperCAmelCase = do_resize _UpperCAmelCase = size _UpperCAmelCase = do_normalize _UpperCAmelCase = image_mean _UpperCAmelCase = image_std _UpperCAmelCase = do_rescale _UpperCAmelCase = rescale_factor _UpperCAmelCase = do_pad def _lowerCamelCase ( self : int) -> str: """simple docstring""" return { "do_resize": self.do_resize, "size": self.size, "do_normalize": self.do_normalize, "image_mean": self.image_mean, "image_std": self.image_std, "do_rescale": self.do_rescale, "rescale_factor": self.rescale_factor, "do_pad": self.do_pad, } def _lowerCamelCase ( self : Dict , A : Optional[int] , A : int=False) -> Union[str, Any]: """simple docstring""" if not batched: _UpperCAmelCase = image_inputs[0] if isinstance(A , Image.Image): _UpperCAmelCase , _UpperCAmelCase = image.size else: _UpperCAmelCase , _UpperCAmelCase = image.shape[1], image.shape[2] if w < h: _UpperCAmelCase = int(self.size['shortest_edge'] * h / w) _UpperCAmelCase = self.size['shortest_edge'] elif w > h: _UpperCAmelCase = self.size['shortest_edge'] _UpperCAmelCase = int(self.size['shortest_edge'] * w / h) else: _UpperCAmelCase = self.size['shortest_edge'] _UpperCAmelCase = self.size['shortest_edge'] else: _UpperCAmelCase = [] for image in image_inputs: _UpperCAmelCase , _UpperCAmelCase = self.get_expected_values([image]) expected_values.append((expected_height, expected_width)) _UpperCAmelCase = max(A , key=lambda A: item[0])[0] _UpperCAmelCase = max(A , key=lambda A: item[1])[1] return expected_height, expected_width @require_torch @require_vision class __lowerCAmelCase ( A , unittest.TestCase ): UpperCamelCase = DetaImageProcessor if is_vision_available() else None def _lowerCamelCase ( self : Dict) -> int: """simple docstring""" _UpperCAmelCase = DetaImageProcessingTester(self) @property def _lowerCamelCase ( self : Tuple) -> Union[str, Any]: """simple docstring""" return self.image_processor_tester.prepare_image_processor_dict() def _lowerCamelCase ( self : Tuple) -> List[Any]: """simple docstring""" _UpperCAmelCase = self.image_processing_class(**self.image_processor_dict) self.assertTrue(hasattr(A , 'image_mean')) self.assertTrue(hasattr(A , 'image_std')) self.assertTrue(hasattr(A , 'do_normalize')) self.assertTrue(hasattr(A , 'do_resize')) self.assertTrue(hasattr(A , 'do_rescale')) self.assertTrue(hasattr(A , 'do_pad')) self.assertTrue(hasattr(A , 'size')) def _lowerCamelCase ( self : Union[str, Any]) -> Optional[int]: """simple docstring""" _UpperCAmelCase = self.image_processing_class.from_dict(self.image_processor_dict) self.assertEqual(image_processor.size , {'shortest_edge': 18, 'longest_edge': 13_33}) self.assertEqual(image_processor.do_pad , A) def _lowerCamelCase ( self : Optional[Any]) -> Dict: """simple docstring""" pass def _lowerCamelCase ( self : List[Any]) -> int: """simple docstring""" _UpperCAmelCase = self.image_processing_class(**self.image_processor_dict) # create random PIL images _UpperCAmelCase = prepare_image_inputs(self.image_processor_tester , equal_resolution=A) for image in image_inputs: self.assertIsInstance(A , Image.Image) # Test not batched input _UpperCAmelCase = image_processing(image_inputs[0] , return_tensors='pt').pixel_values _UpperCAmelCase , _UpperCAmelCase = self.image_processor_tester.get_expected_values(A) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched _UpperCAmelCase , _UpperCAmelCase = self.image_processor_tester.get_expected_values(A , batched=A) _UpperCAmelCase = image_processing(A , return_tensors='pt').pixel_values self.assertEqual( encoded_images.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, expected_height, expected_width, ) , ) def _lowerCamelCase ( self : int) -> List[str]: """simple docstring""" _UpperCAmelCase = self.image_processing_class(**self.image_processor_dict) # create random numpy tensors _UpperCAmelCase = prepare_image_inputs(self.image_processor_tester , equal_resolution=A , numpify=A) for image in image_inputs: self.assertIsInstance(A , np.ndarray) # Test not batched input _UpperCAmelCase = image_processing(image_inputs[0] , return_tensors='pt').pixel_values _UpperCAmelCase , _UpperCAmelCase = self.image_processor_tester.get_expected_values(A) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched _UpperCAmelCase = image_processing(A , return_tensors='pt').pixel_values _UpperCAmelCase , _UpperCAmelCase = self.image_processor_tester.get_expected_values(A , batched=A) self.assertEqual( encoded_images.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, expected_height, expected_width, ) , ) def _lowerCamelCase ( self : Union[str, Any]) -> Dict: """simple docstring""" _UpperCAmelCase = self.image_processing_class(**self.image_processor_dict) # create random PyTorch tensors _UpperCAmelCase = prepare_image_inputs(self.image_processor_tester , equal_resolution=A , torchify=A) for image in image_inputs: self.assertIsInstance(A , torch.Tensor) # Test not batched input _UpperCAmelCase = image_processing(image_inputs[0] , return_tensors='pt').pixel_values _UpperCAmelCase , _UpperCAmelCase = self.image_processor_tester.get_expected_values(A) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched _UpperCAmelCase = image_processing(A , return_tensors='pt').pixel_values _UpperCAmelCase , _UpperCAmelCase = self.image_processor_tester.get_expected_values(A , batched=A) self.assertEqual( encoded_images.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, expected_height, expected_width, ) , ) @slow def _lowerCamelCase ( self : Optional[int]) -> str: """simple docstring""" _UpperCAmelCase = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png') with open('./tests/fixtures/tests_samples/COCO/coco_annotations.txt' , 'r') as f: _UpperCAmelCase = json.loads(f.read()) _UpperCAmelCase = {'image_id': 3_97_69, 'annotations': target} # encode them _UpperCAmelCase = DetaImageProcessor() _UpperCAmelCase = image_processing(images=A , annotations=A , return_tensors='pt') # verify pixel values _UpperCAmelCase = torch.Size([1, 3, 8_00, 10_66]) self.assertEqual(encoding['pixel_values'].shape , A) _UpperCAmelCase = torch.tensor([0.2_7_9_6, 0.3_1_3_8, 0.3_4_8_1]) self.assertTrue(torch.allclose(encoding['pixel_values'][0, 0, 0, :3] , A , atol=1E-4)) # verify area _UpperCAmelCase = torch.tensor([5_8_8_7.9_6_0_0, 1_1_2_5_0.2_0_6_1, 4_8_9_3_5_3.8_4_3_8, 8_3_7_1_2_2.7_5_0_0, 1_4_7_9_6_7.5_1_5_6, 1_6_5_7_3_2.3_4_3_8]) self.assertTrue(torch.allclose(encoding['labels'][0]['area'] , A)) # verify boxes _UpperCAmelCase = torch.Size([6, 4]) self.assertEqual(encoding['labels'][0]['boxes'].shape , A) _UpperCAmelCase = torch.tensor([0.5_5_0_3, 0.2_7_6_5, 0.0_6_0_4, 0.2_2_1_5]) self.assertTrue(torch.allclose(encoding['labels'][0]['boxes'][0] , A , atol=1E-3)) # verify image_id _UpperCAmelCase = torch.tensor([3_97_69]) self.assertTrue(torch.allclose(encoding['labels'][0]['image_id'] , A)) # verify is_crowd _UpperCAmelCase = torch.tensor([0, 0, 0, 0, 0, 0]) self.assertTrue(torch.allclose(encoding['labels'][0]['iscrowd'] , A)) # verify class_labels _UpperCAmelCase = torch.tensor([75, 75, 63, 65, 17, 17]) self.assertTrue(torch.allclose(encoding['labels'][0]['class_labels'] , A)) # verify orig_size _UpperCAmelCase = torch.tensor([4_80, 6_40]) self.assertTrue(torch.allclose(encoding['labels'][0]['orig_size'] , A)) # verify size _UpperCAmelCase = torch.tensor([8_00, 10_66]) self.assertTrue(torch.allclose(encoding['labels'][0]['size'] , A)) @slow def _lowerCamelCase ( self : Union[str, Any]) -> List[Any]: """simple docstring""" _UpperCAmelCase = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png') with open('./tests/fixtures/tests_samples/COCO/coco_panoptic_annotations.txt' , 'r') as f: _UpperCAmelCase = json.loads(f.read()) _UpperCAmelCase = {'file_name': '000000039769.png', 'image_id': 3_97_69, 'segments_info': target} _UpperCAmelCase = pathlib.Path('./tests/fixtures/tests_samples/COCO/coco_panoptic') # encode them _UpperCAmelCase = DetaImageProcessor(format='coco_panoptic') _UpperCAmelCase = image_processing(images=A , annotations=A , masks_path=A , return_tensors='pt') # verify pixel values _UpperCAmelCase = torch.Size([1, 3, 8_00, 10_66]) self.assertEqual(encoding['pixel_values'].shape , A) _UpperCAmelCase = torch.tensor([0.2_7_9_6, 0.3_1_3_8, 0.3_4_8_1]) self.assertTrue(torch.allclose(encoding['pixel_values'][0, 0, 0, :3] , A , atol=1E-4)) # verify area _UpperCAmelCase = torch.tensor([1_4_7_9_7_9.6_8_7_5, 1_6_5_5_2_7.0_4_6_9, 4_8_4_6_3_8.5_9_3_8, 1_1_2_9_2.9_3_7_5, 5_8_7_9.6_5_6_2, 7_6_3_4.1_1_4_7]) self.assertTrue(torch.allclose(encoding['labels'][0]['area'] , A)) # verify boxes _UpperCAmelCase = torch.Size([6, 4]) self.assertEqual(encoding['labels'][0]['boxes'].shape , A) _UpperCAmelCase = torch.tensor([0.2_6_2_5, 0.5_4_3_7, 0.4_6_8_8, 0.8_6_2_5]) self.assertTrue(torch.allclose(encoding['labels'][0]['boxes'][0] , A , atol=1E-3)) # verify image_id _UpperCAmelCase = torch.tensor([3_97_69]) self.assertTrue(torch.allclose(encoding['labels'][0]['image_id'] , A)) # verify is_crowd _UpperCAmelCase = torch.tensor([0, 0, 0, 0, 0, 0]) self.assertTrue(torch.allclose(encoding['labels'][0]['iscrowd'] , A)) # verify class_labels _UpperCAmelCase = torch.tensor([17, 17, 63, 75, 75, 93]) self.assertTrue(torch.allclose(encoding['labels'][0]['class_labels'] , A)) # verify masks _UpperCAmelCase = 82_28_73 self.assertEqual(encoding['labels'][0]['masks'].sum().item() , A) # verify orig_size _UpperCAmelCase = torch.tensor([4_80, 6_40]) self.assertTrue(torch.allclose(encoding['labels'][0]['orig_size'] , A)) # verify size _UpperCAmelCase = torch.tensor([8_00, 10_66]) self.assertTrue(torch.allclose(encoding['labels'][0]['size'] , A))
339
import numpy as np from nltk.translate import meteor_score import datasets from datasets.config import importlib_metadata, version UpperCAmelCase__ = version.parse(importlib_metadata.version("nltk")) if NLTK_VERSION >= version.Version("3.6.4"): from nltk import word_tokenize UpperCAmelCase__ = "\\n@inproceedings{banarjee2005,\n title = {{METEOR}: An Automatic Metric for {MT} Evaluation with Improved Correlation with Human Judgments},\n author = {Banerjee, Satanjeev and Lavie, Alon},\n booktitle = {Proceedings of the {ACL} Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization},\n month = jun,\n year = {2005},\n address = {Ann Arbor, Michigan},\n publisher = {Association for Computational Linguistics},\n url = {https://www.aclweb.org/anthology/W05-0909},\n pages = {65--72},\n}\n" UpperCAmelCase__ = "\\nMETEOR, an automatic metric for machine translation evaluation\nthat is based on a generalized concept of unigram matching between the\nmachine-produced translation and human-produced reference translations.\nUnigrams can be matched based on their surface forms, stemmed forms,\nand meanings; furthermore, METEOR can be easily extended to include more\nadvanced matching strategies. Once all generalized unigram matches\nbetween the two strings have been found, METEOR computes a score for\nthis matching using a combination of unigram-precision, unigram-recall, and\na measure of fragmentation that is designed to directly capture how\nwell-ordered the matched words in the machine translation are in relation\nto the reference.\n\nMETEOR gets an R correlation value of 0.347 with human evaluation on the Arabic\ndata and 0.331 on the Chinese data. This is shown to be an improvement on\nusing simply unigram-precision, unigram-recall and their harmonic F1\ncombination.\n" UpperCAmelCase__ = "\nComputes METEOR score of translated segments against one or more references.\nArgs:\n predictions: list of predictions to score. Each prediction\n should be a string with tokens separated by spaces.\n references: list of reference for each prediction. Each\n reference should be a string with tokens separated by spaces.\n alpha: Parameter for controlling relative weights of precision and recall. default: 0.9\n beta: Parameter for controlling shape of penalty as a function of fragmentation. default: 3\n gamma: Relative weight assigned to fragmentation penalty. default: 0.5\nReturns:\n 'meteor': meteor score.\nExamples:\n\n >>> meteor = datasets.load_metric('meteor')\n >>> predictions = [\"It is a guide to action which ensures that the military always obeys the commands of the party\"]\n >>> references = [\"It is a guide to action that ensures that the military will forever heed Party commands\"]\n >>> results = meteor.compute(predictions=predictions, references=references)\n >>> print(round(results[\"meteor\"], 4))\n 0.6944\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class __lowerCAmelCase ( datasets.Metric ): def _lowerCamelCase ( self : List[Any]) -> List[Any]: """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': datasets.Value('string' , id='sequence'), 'references': datasets.Value('string' , id='sequence'), }) , codebase_urls=['https://github.com/nltk/nltk/blob/develop/nltk/translate/meteor_score.py'] , reference_urls=[ 'https://www.nltk.org/api/nltk.translate.html#module-nltk.translate.meteor_score', 'https://en.wikipedia.org/wiki/METEOR', ] , ) def _lowerCamelCase ( self : Optional[Any] , A : List[str]) -> List[Any]: """simple docstring""" import nltk nltk.download('wordnet') if NLTK_VERSION >= version.Version('3.6.5'): nltk.download('punkt') if NLTK_VERSION >= version.Version('3.6.6'): nltk.download('omw-1.4') def _lowerCamelCase ( self : Optional[Any] , A : Tuple , A : Optional[int] , A : List[Any]=0.9 , A : Optional[Any]=3 , A : Optional[int]=0.5) -> Any: """simple docstring""" if NLTK_VERSION >= version.Version('3.6.5'): _UpperCAmelCase = [ meteor_score.single_meteor_score( word_tokenize(A) , word_tokenize(A) , alpha=A , beta=A , gamma=A) for ref, pred in zip(A , A) ] else: _UpperCAmelCase = [ meteor_score.single_meteor_score(A , A , alpha=A , beta=A , gamma=A) for ref, pred in zip(A , A) ] return {"meteor": np.mean(A)}
339
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_torch_available, ) UpperCAmelCase__ = { "configuration_falcon": ["FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP", "FalconConfig"], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase__ = [ "FALCON_PRETRAINED_MODEL_ARCHIVE_LIST", "FalconForCausalLM", "FalconModel", "FalconPreTrainedModel", "FalconForSequenceClassification", "FalconForTokenClassification", "FalconForQuestionAnswering", ] if TYPE_CHECKING: from .configuration_falcon import FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP, FalconConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_falcon import ( FALCON_PRETRAINED_MODEL_ARCHIVE_LIST, FalconForCausalLM, FalconForQuestionAnswering, FalconForSequenceClassification, FalconForTokenClassification, FalconModel, FalconPreTrainedModel, ) else: import sys UpperCAmelCase__ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
339
import argparse import hashlib import os import urllib import warnings import torch from torch import nn from tqdm import tqdm from transformers import WhisperConfig, WhisperForConditionalGeneration UpperCAmelCase__ = { "tiny.en": "https://openaipublic.azureedge.net/main/whisper/models/d3dd57d32accea0b295c96e26691aa14d8822fac7d9d27d5dc00b4ca2826dd03/tiny.en.pt", "tiny": "https://openaipublic.azureedge.net/main/whisper/models/65147644a518d12f04e32d6f3b26facc3f8dd46e5390956a9424a650c0ce22b9/tiny.pt", "base.en": "https://openaipublic.azureedge.net/main/whisper/models/25a8566e1d0c1e2231d1c762132cd20e0f96a85d16145c3a00adf5d1ac670ead/base.en.pt", "base": "https://openaipublic.azureedge.net/main/whisper/models/ed3a0b6b1c0edf879ad9b11b1af5a0e6ab5db9205f891f668f8b0e6c6326e34e/base.pt", "small.en": "https://openaipublic.azureedge.net/main/whisper/models/f953ad0fd29cacd07d5a9eda5624af0f6bcf2258be67c92b79389873d91e0872/small.en.pt", "small": "https://openaipublic.azureedge.net/main/whisper/models/9ecf779972d90ba49c06d968637d720dd632c55bbf19d441fb42bf17a411e794/small.pt", "medium.en": "https://openaipublic.azureedge.net/main/whisper/models/d7440d1dc186f76616474e0ff0b3b6b879abc9d1a4926b7adfa41db2d497ab4f/medium.en.pt", "medium": "https://openaipublic.azureedge.net/main/whisper/models/345ae4da62f9b3d59415adc60127b97c714f32e89e936602e85993674d08dcb1/medium.pt", "large": "https://openaipublic.azureedge.net/main/whisper/models/e4b87e7e0bf463eb8e6956e646f1e277e901512310def2c24bf0e11bd3c28e9a/large.pt", "large-v2": "https://openaipublic.azureedge.net/main/whisper/models/81f7c96c852ee8fc832187b0132e569d6c3065a3252ed18e56effd0b6a73e524/large-v2.pt", } def A ( _UpperCAmelCase : Optional[int] ) -> str: '''simple docstring''' _UpperCAmelCase = ['layers', 'blocks'] for k in ignore_keys: state_dict.pop(_UpperCAmelCase , _UpperCAmelCase ) UpperCAmelCase__ = { "blocks": "layers", "mlp.0": "fc1", "mlp.2": "fc2", "mlp_ln": "final_layer_norm", ".attn.query": ".self_attn.q_proj", ".attn.key": ".self_attn.k_proj", ".attn.value": ".self_attn.v_proj", ".attn_ln": ".self_attn_layer_norm", ".attn.out": ".self_attn.out_proj", ".cross_attn.query": ".encoder_attn.q_proj", ".cross_attn.key": ".encoder_attn.k_proj", ".cross_attn.value": ".encoder_attn.v_proj", ".cross_attn_ln": ".encoder_attn_layer_norm", ".cross_attn.out": ".encoder_attn.out_proj", "decoder.ln.": "decoder.layer_norm.", "encoder.ln.": "encoder.layer_norm.", "token_embedding": "embed_tokens", "encoder.positional_embedding": "encoder.embed_positions.weight", "decoder.positional_embedding": "decoder.embed_positions.weight", "ln_post": "layer_norm", } def A ( _UpperCAmelCase : Dict ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = list(s_dict.keys() ) for key in keys: _UpperCAmelCase = key for k, v in WHISPER_MAPPING.items(): if k in key: _UpperCAmelCase = new_key.replace(_UpperCAmelCase , _UpperCAmelCase ) print(F"{key} -> {new_key}" ) _UpperCAmelCase = s_dict.pop(_UpperCAmelCase ) return s_dict def A ( _UpperCAmelCase : List[Any] ) -> Union[str, Any]: '''simple docstring''' _UpperCAmelCase , _UpperCAmelCase = emb.weight.shape _UpperCAmelCase = nn.Linear(_UpperCAmelCase , _UpperCAmelCase , bias=_UpperCAmelCase ) _UpperCAmelCase = emb.weight.data return lin_layer def A ( _UpperCAmelCase : str , _UpperCAmelCase : str ) -> bytes: '''simple docstring''' os.makedirs(_UpperCAmelCase , exist_ok=_UpperCAmelCase ) _UpperCAmelCase = os.path.basename(_UpperCAmelCase ) _UpperCAmelCase = url.split('/' )[-2] _UpperCAmelCase = os.path.join(_UpperCAmelCase , _UpperCAmelCase ) if os.path.exists(_UpperCAmelCase ) and not os.path.isfile(_UpperCAmelCase ): raise RuntimeError(F"{download_target} exists and is not a regular file" ) if os.path.isfile(_UpperCAmelCase ): _UpperCAmelCase = open(_UpperCAmelCase , 'rb' ).read() if hashlib.shaaaa(_UpperCAmelCase ).hexdigest() == expected_shaaaa: return model_bytes else: warnings.warn(F"{download_target} exists, but the SHA256 checksum does not match; re-downloading the file" ) with urllib.request.urlopen(_UpperCAmelCase ) as source, open(_UpperCAmelCase , 'wb' ) as output: with tqdm( total=int(source.info().get('Content-Length' ) ) , ncols=80 , unit='iB' , unit_scale=_UpperCAmelCase , unit_divisor=1_024 ) as loop: while True: _UpperCAmelCase = source.read(8_192 ) if not buffer: break output.write(_UpperCAmelCase ) loop.update(len(_UpperCAmelCase ) ) _UpperCAmelCase = open(_UpperCAmelCase , 'rb' ).read() if hashlib.shaaaa(_UpperCAmelCase ).hexdigest() != expected_shaaaa: raise RuntimeError( 'Model has been downloaded but the SHA256 checksum does not not match. Please retry loading the model.' ) return model_bytes def A ( _UpperCAmelCase : List[Any] , _UpperCAmelCase : Any ) -> Optional[int]: '''simple docstring''' if ".pt" not in checkpoint_path: _UpperCAmelCase = _download(_MODELS[checkpoint_path] ) else: _UpperCAmelCase = torch.load(_UpperCAmelCase , map_location='cpu' ) _UpperCAmelCase = original_checkpoint['dims'] _UpperCAmelCase = original_checkpoint['model_state_dict'] _UpperCAmelCase = state_dict['decoder.token_embedding.weight'] remove_ignore_keys_(_UpperCAmelCase ) rename_keys(_UpperCAmelCase ) _UpperCAmelCase = True _UpperCAmelCase = state_dict['decoder.layers.0.fc1.weight'].shape[0] _UpperCAmelCase = WhisperConfig( vocab_size=dimensions['n_vocab'] , encoder_ffn_dim=_UpperCAmelCase , decoder_ffn_dim=_UpperCAmelCase , num_mel_bins=dimensions['n_mels'] , d_model=dimensions['n_audio_state'] , max_target_positions=dimensions['n_text_ctx'] , encoder_layers=dimensions['n_audio_layer'] , encoder_attention_heads=dimensions['n_audio_head'] , decoder_layers=dimensions['n_text_layer'] , decoder_attention_heads=dimensions['n_text_state'] , max_source_positions=dimensions['n_audio_ctx'] , ) _UpperCAmelCase = WhisperForConditionalGeneration(_UpperCAmelCase ) _UpperCAmelCase , _UpperCAmelCase = model.model.load_state_dict(_UpperCAmelCase , strict=_UpperCAmelCase ) if len(_UpperCAmelCase ) > 0 and not set(_UpperCAmelCase ) <= { "encoder.embed_positions.weights", "decoder.embed_positions.weights", }: raise ValueError( 'Only `encoder.embed_positions.weights` and `decoder.embed_positions.weights` are allowed to be missing,' F" but all the following weights are missing {missing}" ) if tie_embeds: _UpperCAmelCase = make_linear_from_emb(model.model.decoder.embed_tokens ) else: _UpperCAmelCase = proj_out_weights model.save_pretrained(_UpperCAmelCase ) if __name__ == "__main__": UpperCAmelCase__ = argparse.ArgumentParser() # # Required parameters parser.add_argument("--checkpoint_path", type=str, help="Patht to the downloaded checkpoints") parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.") UpperCAmelCase__ = parser.parse_args() convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)
339
1
import argparse import torch from torch import nn from transformers import SpeechaTextConfig, SpeechaTextForConditionalGeneration def A ( _UpperCAmelCase : Any ) -> Tuple: '''simple docstring''' _UpperCAmelCase = [ 'encoder.version', 'decoder.version', 'model.encoder.version', 'model.decoder.version', 'decoder.output_projection.weight', '_float_tensor', 'encoder.embed_positions._float_tensor', 'decoder.embed_positions._float_tensor', ] for k in ignore_keys: state_dict.pop(_UpperCAmelCase , _UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[int] ) -> str: '''simple docstring''' _UpperCAmelCase = list(s_dict.keys() ) for key in keys: if "transformer_layers" in key: _UpperCAmelCase = s_dict.pop(_UpperCAmelCase ) elif "subsample" in key: _UpperCAmelCase = s_dict.pop(_UpperCAmelCase ) def A ( _UpperCAmelCase : List[Any] ) -> Union[str, Any]: '''simple docstring''' _UpperCAmelCase , _UpperCAmelCase = emb.weight.shape _UpperCAmelCase = nn.Linear(_UpperCAmelCase , _UpperCAmelCase , bias=_UpperCAmelCase ) _UpperCAmelCase = emb.weight.data return lin_layer def A ( _UpperCAmelCase : Union[str, Any] , _UpperCAmelCase : List[Any] ) -> str: '''simple docstring''' _UpperCAmelCase = torch.load(_UpperCAmelCase , map_location='cpu' ) _UpperCAmelCase = mam_aaa['args'] _UpperCAmelCase = mam_aaa['model'] _UpperCAmelCase = state_dict['decoder.output_projection.weight'] remove_ignore_keys_(_UpperCAmelCase ) rename_keys(_UpperCAmelCase ) _UpperCAmelCase = state_dict['decoder.embed_tokens.weight'].shape[0] _UpperCAmelCase = args.share_decoder_input_output_embed _UpperCAmelCase = [int(_UpperCAmelCase ) for i in args.conv_kernel_sizes.split(',' )] _UpperCAmelCase = SpeechaTextConfig( vocab_size=_UpperCAmelCase , max_source_positions=args.max_source_positions , max_target_positions=args.max_target_positions , encoder_layers=args.encoder_layers , decoder_layers=args.decoder_layers , encoder_attention_heads=args.encoder_attention_heads , decoder_attention_heads=args.decoder_attention_heads , encoder_ffn_dim=args.encoder_ffn_embed_dim , decoder_ffn_dim=args.decoder_ffn_embed_dim , d_model=args.encoder_embed_dim , dropout=args.dropout , attention_dropout=args.attention_dropout , activation_dropout=args.activation_dropout , activation_function='relu' , num_conv_layers=len(_UpperCAmelCase ) , conv_channels=args.conv_channels , conv_kernel_sizes=_UpperCAmelCase , input_feat_per_channel=args.input_feat_per_channel , input_channels=args.input_channels , tie_word_embeddings=_UpperCAmelCase , num_beams=5 , max_length=200 , use_cache=_UpperCAmelCase , decoder_start_token_id=2 , early_stopping=_UpperCAmelCase , ) _UpperCAmelCase = SpeechaTextForConditionalGeneration(_UpperCAmelCase ) _UpperCAmelCase , _UpperCAmelCase = model.model.load_state_dict(_UpperCAmelCase , strict=_UpperCAmelCase ) if len(_UpperCAmelCase ) > 0 and not set(_UpperCAmelCase ) <= { "encoder.embed_positions.weights", "decoder.embed_positions.weights", }: raise ValueError( 'Only `encoder.embed_positions.weights` and `decoder.embed_positions.weights` are allowed to be missing,' F" but all the following weights are missing {missing}" ) if tie_embeds: _UpperCAmelCase = make_linear_from_emb(model.model.decoder.embed_tokens ) else: _UpperCAmelCase = lm_head_weights model.save_pretrained(_UpperCAmelCase ) if __name__ == "__main__": UpperCAmelCase__ = argparse.ArgumentParser() # Required parameters parser.add_argument("--fairseq_path", type=str, help="Path to the fairseq model (.pt) file.") parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.") UpperCAmelCase__ = parser.parse_args() convert_fairseq_sat_checkpoint_to_tfms(args.fairseq_path, args.pytorch_dump_folder_path)
339
from typing import List import datasets from datasets.tasks import AudioClassification from ..folder_based_builder import folder_based_builder UpperCAmelCase__ = datasets.utils.logging.get_logger(__name__) class __lowerCAmelCase ( folder_based_builder.FolderBasedBuilderConfig ): UpperCamelCase = None UpperCamelCase = None class __lowerCAmelCase ( folder_based_builder.FolderBasedBuilder ): UpperCamelCase = datasets.Audio() UpperCamelCase = '''audio''' UpperCamelCase = AudioFolderConfig UpperCamelCase = 42 # definition at the bottom of the script UpperCamelCase = AudioClassification(audio_column='''audio''' , label_column='''label''' ) UpperCAmelCase__ = [ ".aiff", ".au", ".avr", ".caf", ".flac", ".htk", ".svx", ".mat4", ".mat5", ".mpc2k", ".ogg", ".paf", ".pvf", ".raw", ".rf64", ".sd2", ".sds", ".ircam", ".voc", ".w64", ".wav", ".nist", ".wavex", ".wve", ".xi", ".mp3", ".opus", ] UpperCAmelCase__ = AUDIO_EXTENSIONS
339
1
from collections.abc import Generator from math import sin def A ( _UpperCAmelCase : bytes ) -> bytes: '''simple docstring''' if len(_UpperCAmelCase ) != 32: raise ValueError('Input must be of length 32' ) _UpperCAmelCase = B'' for i in [3, 2, 1, 0]: little_endian += string_aa[8 * i : 8 * i + 8] return little_endian def A ( _UpperCAmelCase : int ) -> bytes: '''simple docstring''' if i < 0: raise ValueError('Input must be non-negative' ) _UpperCAmelCase = format(_UpperCAmelCase , '08x' )[-8:] _UpperCAmelCase = B'' for i in [3, 2, 1, 0]: little_endian_hex += hex_rep[2 * i : 2 * i + 2].encode('utf-8' ) return little_endian_hex def A ( _UpperCAmelCase : bytes ) -> bytes: '''simple docstring''' _UpperCAmelCase = B'' for char in message: bit_string += format(_UpperCAmelCase , '08b' ).encode('utf-8' ) _UpperCAmelCase = format(len(_UpperCAmelCase ) , '064b' ).encode('utf-8' ) # Pad bit_string to a multiple of 512 chars bit_string += b"1" while len(_UpperCAmelCase ) % 512 != 448: bit_string += b"0" bit_string += to_little_endian(start_len[32:] ) + to_little_endian(start_len[:32] ) return bit_string def A ( _UpperCAmelCase : bytes ) -> Generator[list[int], None, None]: '''simple docstring''' if len(_UpperCAmelCase ) % 512 != 0: raise ValueError('Input must have length that\'s a multiple of 512' ) for pos in range(0 , len(_UpperCAmelCase ) , 512 ): _UpperCAmelCase = bit_string[pos : pos + 512] _UpperCAmelCase = [] for i in range(0 , 512 , 32 ): block_words.append(int(to_little_endian(block[i : i + 32] ) , 2 ) ) yield block_words def A ( _UpperCAmelCase : int ) -> int: '''simple docstring''' if i < 0: raise ValueError('Input must be non-negative' ) _UpperCAmelCase = format(_UpperCAmelCase , '032b' ) _UpperCAmelCase = '' for c in i_str: new_str += "1" if c == "0" else "0" return int(_UpperCAmelCase , 2 ) def A ( _UpperCAmelCase : int , _UpperCAmelCase : int ) -> int: '''simple docstring''' return (a + b) % 2**32 def A ( _UpperCAmelCase : int , _UpperCAmelCase : int ) -> int: '''simple docstring''' if i < 0: raise ValueError('Input must be non-negative' ) if shift < 0: raise ValueError('Shift must be non-negative' ) return ((i << shift) ^ (i >> (32 - shift))) % 2**32 def A ( _UpperCAmelCase : bytes ) -> bytes: '''simple docstring''' _UpperCAmelCase = preprocess(_UpperCAmelCase ) _UpperCAmelCase = [int(2**32 * abs(sin(i + 1 ) ) ) for i in range(64 )] # Starting states _UpperCAmelCase = 0x67_45_23_01 _UpperCAmelCase = 0xEF_CD_AB_89 _UpperCAmelCase = 0x98_BA_DC_FE _UpperCAmelCase = 0x10_32_54_76 _UpperCAmelCase = [ 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, ] # Process bit string in chunks, each with 16 32-char words for block_words in get_block_words(_UpperCAmelCase ): _UpperCAmelCase = aa _UpperCAmelCase = ba _UpperCAmelCase = ca _UpperCAmelCase = da # Hash current chunk for i in range(64 ): if i <= 15: # f = (b & c) | (not_32(b) & d) # Alternate definition for f _UpperCAmelCase = d ^ (b & (c ^ d)) _UpperCAmelCase = i elif i <= 31: # f = (d & b) | (not_32(d) & c) # Alternate definition for f _UpperCAmelCase = c ^ (d & (b ^ c)) _UpperCAmelCase = (5 * i + 1) % 16 elif i <= 47: _UpperCAmelCase = b ^ c ^ d _UpperCAmelCase = (3 * i + 5) % 16 else: _UpperCAmelCase = c ^ (b | not_aa(_UpperCAmelCase )) _UpperCAmelCase = (7 * i) % 16 _UpperCAmelCase = (f + a + added_consts[i] + block_words[g]) % 2**32 _UpperCAmelCase = d _UpperCAmelCase = c _UpperCAmelCase = b _UpperCAmelCase = sum_aa(_UpperCAmelCase , left_rotate_aa(_UpperCAmelCase , shift_amounts[i] ) ) # Add hashed chunk to running total _UpperCAmelCase = sum_aa(_UpperCAmelCase , _UpperCAmelCase ) _UpperCAmelCase = sum_aa(_UpperCAmelCase , _UpperCAmelCase ) _UpperCAmelCase = sum_aa(_UpperCAmelCase , _UpperCAmelCase ) _UpperCAmelCase = sum_aa(_UpperCAmelCase , _UpperCAmelCase ) _UpperCAmelCase = reformat_hex(_UpperCAmelCase ) + reformat_hex(_UpperCAmelCase ) + reformat_hex(_UpperCAmelCase ) + reformat_hex(_UpperCAmelCase ) return digest if __name__ == "__main__": import doctest doctest.testmod()
339
import sys from collections import defaultdict class __lowerCAmelCase : def __init__( self : int) -> str: """simple docstring""" _UpperCAmelCase = [] def _lowerCamelCase ( self : Any , A : List[str]) -> int: """simple docstring""" return self.node_position[vertex] def _lowerCamelCase ( self : Optional[Any] , A : Optional[int] , A : str) -> List[str]: """simple docstring""" _UpperCAmelCase = pos def _lowerCamelCase ( self : Tuple , A : Tuple , A : Dict , A : List[str] , A : Optional[Any]) -> Dict: """simple docstring""" if start > size // 2 - 1: return else: if 2 * start + 2 >= size: _UpperCAmelCase = 2 * start + 1 else: if heap[2 * start + 1] < heap[2 * start + 2]: _UpperCAmelCase = 2 * start + 1 else: _UpperCAmelCase = 2 * start + 2 if heap[smallest_child] < heap[start]: _UpperCAmelCase , _UpperCAmelCase = heap[smallest_child], positions[smallest_child] _UpperCAmelCase , _UpperCAmelCase = ( heap[start], positions[start], ) _UpperCAmelCase , _UpperCAmelCase = temp, tempa _UpperCAmelCase = self.get_position(positions[smallest_child]) self.set_position( positions[smallest_child] , self.get_position(positions[start])) self.set_position(positions[start] , A) self.top_to_bottom(A , A , A , A) def _lowerCamelCase ( self : Optional[int] , A : str , A : Optional[Any] , A : Optional[int] , A : str) -> Any: """simple docstring""" _UpperCAmelCase = position[index] while index != 0: _UpperCAmelCase = int((index - 2) / 2) if index % 2 == 0 else int((index - 1) / 2) if val < heap[parent]: _UpperCAmelCase = heap[parent] _UpperCAmelCase = position[parent] self.set_position(position[parent] , A) else: _UpperCAmelCase = val _UpperCAmelCase = temp self.set_position(A , A) break _UpperCAmelCase = parent else: _UpperCAmelCase = val _UpperCAmelCase = temp self.set_position(A , 0) def _lowerCamelCase ( self : Union[str, Any] , A : Optional[int] , A : Tuple) -> str: """simple docstring""" _UpperCAmelCase = len(A) // 2 - 1 for i in range(A , -1 , -1): self.top_to_bottom(A , A , len(A) , A) def _lowerCamelCase ( self : Optional[int] , A : int , A : str) -> List[str]: """simple docstring""" _UpperCAmelCase = positions[0] _UpperCAmelCase = sys.maxsize self.top_to_bottom(A , 0 , len(A) , A) return temp def A ( _UpperCAmelCase : int ) -> Any: '''simple docstring''' _UpperCAmelCase = Heap() _UpperCAmelCase = [0] * len(_UpperCAmelCase ) _UpperCAmelCase = [-1] * len(_UpperCAmelCase ) # Neighboring Tree Vertex of selected vertex # Minimum Distance of explored vertex with neighboring vertex of partial tree # formed in graph _UpperCAmelCase = [] # Heap of Distance of vertices from their neighboring vertex _UpperCAmelCase = [] for vertex in range(len(_UpperCAmelCase ) ): distance_tv.append(sys.maxsize ) positions.append(_UpperCAmelCase ) heap.node_position.append(_UpperCAmelCase ) _UpperCAmelCase = [] _UpperCAmelCase = 1 _UpperCAmelCase = sys.maxsize for neighbor, distance in adjacency_list[0]: _UpperCAmelCase = 0 _UpperCAmelCase = distance heap.heapify(_UpperCAmelCase , _UpperCAmelCase ) for _ in range(1 , len(_UpperCAmelCase ) ): _UpperCAmelCase = heap.delete_minimum(_UpperCAmelCase , _UpperCAmelCase ) if visited[vertex] == 0: tree_edges.append((nbr_tv[vertex], vertex) ) _UpperCAmelCase = 1 for neighbor, distance in adjacency_list[vertex]: if ( visited[neighbor] == 0 and distance < distance_tv[heap.get_position(_UpperCAmelCase )] ): _UpperCAmelCase = distance heap.bottom_to_top( _UpperCAmelCase , heap.get_position(_UpperCAmelCase ) , _UpperCAmelCase , _UpperCAmelCase ) _UpperCAmelCase = vertex return tree_edges if __name__ == "__main__": # pragma: no cover # < --------- Prims Algorithm --------- > UpperCAmelCase__ = int(input("Enter number of edges: ").strip()) UpperCAmelCase__ = defaultdict(list) for _ in range(edges_number): UpperCAmelCase__ = [int(x) for x in input().strip().split()] adjacency_list[edge[0]].append([edge[1], edge[2]]) adjacency_list[edge[1]].append([edge[0], edge[2]]) print(prisms_algorithm(adjacency_list))
339
1
import math import os import sys def A ( _UpperCAmelCase : str ) -> str: '''simple docstring''' _UpperCAmelCase = '' try: with open(_UpperCAmelCase , 'rb' ) as binary_file: _UpperCAmelCase = binary_file.read() for dat in data: _UpperCAmelCase = F"{dat:08b}" result += curr_byte return result except OSError: print('File not accessible' ) sys.exit() def A ( _UpperCAmelCase : dict[str, str] , _UpperCAmelCase : str , _UpperCAmelCase : int , _UpperCAmelCase : str ) -> None: '''simple docstring''' lexicon.pop(_UpperCAmelCase ) _UpperCAmelCase = last_match_id if math.loga(_UpperCAmelCase ).is_integer(): for curr_key in lexicon: _UpperCAmelCase = '0' + lexicon[curr_key] _UpperCAmelCase = bin(_UpperCAmelCase )[2:] def A ( _UpperCAmelCase : str ) -> str: '''simple docstring''' _UpperCAmelCase = {'0': '0', '1': '1'} _UpperCAmelCase , _UpperCAmelCase = '', '' _UpperCAmelCase = len(_UpperCAmelCase ) for i in range(len(_UpperCAmelCase ) ): curr_string += data_bits[i] if curr_string not in lexicon: continue _UpperCAmelCase = lexicon[curr_string] result += last_match_id add_key_to_lexicon(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) index += 1 _UpperCAmelCase = '' while curr_string != "" and curr_string not in lexicon: curr_string += "0" if curr_string != "": _UpperCAmelCase = lexicon[curr_string] result += last_match_id return result def A ( _UpperCAmelCase : str , _UpperCAmelCase : str ) -> str: '''simple docstring''' _UpperCAmelCase = os.path.getsize(_UpperCAmelCase ) _UpperCAmelCase = bin(_UpperCAmelCase )[2:] _UpperCAmelCase = len(_UpperCAmelCase ) return "0" * (length_length - 1) + file_length_binary + compressed def A ( _UpperCAmelCase : str , _UpperCAmelCase : str ) -> None: '''simple docstring''' _UpperCAmelCase = 8 try: with open(_UpperCAmelCase , 'wb' ) as opened_file: _UpperCAmelCase = [ to_write[i : i + byte_length] for i in range(0 , len(_UpperCAmelCase ) , _UpperCAmelCase ) ] if len(result_byte_array[-1] ) % byte_length == 0: result_byte_array.append('10000000' ) else: result_byte_array[-1] += "1" + "0" * ( byte_length - len(result_byte_array[-1] ) - 1 ) for elem in result_byte_array: opened_file.write(int(_UpperCAmelCase , 2 ).to_bytes(1 , byteorder='big' ) ) except OSError: print('File not accessible' ) sys.exit() def A ( _UpperCAmelCase : str , _UpperCAmelCase : str ) -> None: '''simple docstring''' _UpperCAmelCase = read_file_binary(_UpperCAmelCase ) _UpperCAmelCase = compress_data(_UpperCAmelCase ) _UpperCAmelCase = add_file_length(_UpperCAmelCase , _UpperCAmelCase ) write_file_binary(_UpperCAmelCase , _UpperCAmelCase ) if __name__ == "__main__": compress(sys.argv[1], sys.argv[2])
339
import torch from transformers import CamembertForMaskedLM, CamembertTokenizer def A ( _UpperCAmelCase : str , _UpperCAmelCase : Any , _UpperCAmelCase : List[str] , _UpperCAmelCase : Optional[int]=5 ) -> List[Any]: '''simple docstring''' # Adapted from https://github.com/pytorch/fairseq/blob/master/fairseq/models/roberta/hub_interface.py assert masked_input.count('<mask>' ) == 1 _UpperCAmelCase = torch.tensor(tokenizer.encode(_UpperCAmelCase , add_special_tokens=_UpperCAmelCase ) ).unsqueeze(0 ) # Batch size 1 _UpperCAmelCase = model(_UpperCAmelCase )[0] # The last hidden-state is the first element of the output tuple _UpperCAmelCase = (input_ids.squeeze() == tokenizer.mask_token_id).nonzero().item() _UpperCAmelCase = logits[0, masked_index, :] _UpperCAmelCase = logits.softmax(dim=0 ) _UpperCAmelCase , _UpperCAmelCase = prob.topk(k=_UpperCAmelCase , dim=0 ) _UpperCAmelCase = ' '.join( [tokenizer.convert_ids_to_tokens(indices[i].item() ) for i in range(len(_UpperCAmelCase ) )] ) _UpperCAmelCase = tokenizer.mask_token _UpperCAmelCase = [] for index, predicted_token_bpe in enumerate(topk_predicted_token_bpe.split(' ' ) ): _UpperCAmelCase = predicted_token_bpe.replace('\u2581' , ' ' ) if " {0}".format(_UpperCAmelCase ) in masked_input: topk_filled_outputs.append( ( masked_input.replace(' {0}'.format(_UpperCAmelCase ) , _UpperCAmelCase ), values[index].item(), predicted_token, ) ) else: topk_filled_outputs.append( ( masked_input.replace(_UpperCAmelCase , _UpperCAmelCase ), values[index].item(), predicted_token, ) ) return topk_filled_outputs UpperCAmelCase__ = CamembertTokenizer.from_pretrained("camembert-base") UpperCAmelCase__ = CamembertForMaskedLM.from_pretrained("camembert-base") model.eval() UpperCAmelCase__ = "Le camembert est <mask> :)" print(fill_mask(masked_input, model, tokenizer, topk=3))
339
1
from math import asin, atan, cos, radians, sin, sqrt, tan UpperCAmelCase__ = 637_8137.0 UpperCAmelCase__ = 635_6752.31_4245 UpperCAmelCase__ = 637_8137 def A ( _UpperCAmelCase : float , _UpperCAmelCase : float , _UpperCAmelCase : float , _UpperCAmelCase : float ) -> float: '''simple docstring''' _UpperCAmelCase = (AXIS_A - AXIS_B) / AXIS_A _UpperCAmelCase = atan((1 - flattening) * tan(radians(_UpperCAmelCase ) ) ) _UpperCAmelCase = atan((1 - flattening) * tan(radians(_UpperCAmelCase ) ) ) _UpperCAmelCase = radians(_UpperCAmelCase ) _UpperCAmelCase = radians(_UpperCAmelCase ) # Equation _UpperCAmelCase = sin((phi_a - phi_a) / 2 ) _UpperCAmelCase = sin((lambda_a - lambda_a) / 2 ) # Square both values sin_sq_phi *= sin_sq_phi sin_sq_lambda *= sin_sq_lambda _UpperCAmelCase = sqrt(sin_sq_phi + (cos(_UpperCAmelCase ) * cos(_UpperCAmelCase ) * sin_sq_lambda) ) return 2 * RADIUS * asin(_UpperCAmelCase ) if __name__ == "__main__": import doctest doctest.testmod()
339
import math import unittest def A ( _UpperCAmelCase : int ) -> bool: '''simple docstring''' assert isinstance(_UpperCAmelCase , _UpperCAmelCase ) and ( number >= 0 ), "'number' must been an int and positive" if 1 < number < 4: # 2 and 3 are primes return True elif number < 2 or number % 2 == 0 or number % 3 == 0: # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes return False # All primes number are in format of 6k +/- 1 for i in range(5 , int(math.sqrt(_UpperCAmelCase ) + 1 ) , 6 ): if number % i == 0 or number % (i + 2) == 0: return False return True class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Tuple) -> Union[str, Any]: """simple docstring""" self.assertTrue(is_prime(2)) self.assertTrue(is_prime(3)) self.assertTrue(is_prime(5)) self.assertTrue(is_prime(7)) self.assertTrue(is_prime(11)) self.assertTrue(is_prime(13)) self.assertTrue(is_prime(17)) self.assertTrue(is_prime(19)) self.assertTrue(is_prime(23)) self.assertTrue(is_prime(29)) def _lowerCamelCase ( self : Optional[int]) -> Any: """simple docstring""" with self.assertRaises(A): is_prime(-19) self.assertFalse( is_prime(0) , 'Zero doesn\'t have any positive factors, primes must have exactly two.' , ) self.assertFalse( is_prime(1) , 'One only has 1 positive factor, primes must have exactly two.' , ) self.assertFalse(is_prime(2 * 2)) self.assertFalse(is_prime(2 * 3)) self.assertFalse(is_prime(3 * 3)) self.assertFalse(is_prime(3 * 5)) self.assertFalse(is_prime(3 * 5 * 7)) if __name__ == "__main__": unittest.main()
339
1
from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCAmelCase__ = logging.get_logger(__name__) UpperCAmelCase__ = { "google/switch-base-8": "https://huggingface.co/google/switch-base-8/blob/main/config.json", } class lowercase_ ( lowercase ): '''simple docstring''' __snake_case = '''switch_transformers''' __snake_case = ['''past_key_values'''] __snake_case = {'''hidden_size''': '''d_model''', '''num_attention_heads''': '''num_heads''', '''num_hidden_layers''': '''num_layers'''} def __init__( self : Dict , __UpperCAmelCase : List[Any]=32_128 , __UpperCAmelCase : List[str]=768 , __UpperCAmelCase : str=64 , __UpperCAmelCase : Dict=2_048 , __UpperCAmelCase : int=64 , __UpperCAmelCase : str=12 , __UpperCAmelCase : Tuple=3 , __UpperCAmelCase : str=12 , __UpperCAmelCase : List[str]=3 , __UpperCAmelCase : Dict=12 , __UpperCAmelCase : List[str]=8 , __UpperCAmelCase : Union[str, Any]=False , __UpperCAmelCase : List[Any]=0.01 , __UpperCAmelCase : Any="float32" , __UpperCAmelCase : Any=False , __UpperCAmelCase : int=32 , __UpperCAmelCase : str=128 , __UpperCAmelCase : Optional[int]=0.1 , __UpperCAmelCase : Optional[Any]=1e-6 , __UpperCAmelCase : Optional[int]=0.001 , __UpperCAmelCase : Any=0.001 , __UpperCAmelCase : List[Any]=1.0 , __UpperCAmelCase : List[Any]="relu" , __UpperCAmelCase : Optional[int]=True , __UpperCAmelCase : Tuple=False , __UpperCAmelCase : str=True , __UpperCAmelCase : Any=0 , __UpperCAmelCase : str=1 , **__UpperCAmelCase : List[Any] , ) ->Optional[int]: """simple docstring""" a = vocab_size a = d_model a = d_kv a = d_ff a = num_sparse_encoder_layers a = num_layers a = ( num_decoder_layers if num_decoder_layers is not None else self.num_layers ) # default = symmetry a = num_sparse_decoder_layers # This tells us, each how many encoder layer we'll have to set a sparse layer. if self.num_sparse_encoder_layers > 0: a = self.num_layers // self.num_sparse_encoder_layers else: a = self.num_layers # HACK: this will create 0 sparse layers # This tells us, each how many encoder layer we'll have to set a sparse layer. if self.num_sparse_decoder_layers > 0: a = self.num_decoder_layers // self.num_sparse_decoder_layers else: a = self.num_decoder_layers # HACK: this will create 0 sparse layers a = num_heads a = num_experts a = expert_capacity a = router_bias a = router_jitter_noise if router_dtype not in ["float32", "float16", "bfloat16"]: raise ValueError(F"""`router_dtype` must be one of 'float32', 'float16' or 'bfloat16', got {router_dtype}""" ) a = router_dtype a = router_ignore_padding_tokens a = relative_attention_num_buckets a = relative_attention_max_distance a = dropout_rate a = layer_norm_epsilon a = initializer_factor a = feed_forward_proj a = use_cache a = add_router_probs a = router_z_loss_coef a = router_aux_loss_coef a = self.feed_forward_proj.split('''-''' ) a = act_info[-1] a = act_info[0] == '''gated''' if len(__UpperCAmelCase ) > 1 and act_info[0] != "gated" or len(__UpperCAmelCase ) > 2: raise ValueError( F"""`feed_forward_proj`: {feed_forward_proj} is not a valid activation function of the dense layer.""" '''Please make sure `feed_forward_proj` is of the format `gated-{ACT_FN}` or `{ACT_FN}`, e.g. ''' '''\'gated-gelu\' or \'relu\'''' ) # for backwards compatibility if feed_forward_proj == "gated-gelu": a = '''gelu_new''' super().__init__( pad_token_id=__UpperCAmelCase , eos_token_id=__UpperCAmelCase , is_encoder_decoder=__UpperCAmelCase , **__UpperCAmelCase , )
0
from typing import Dict, List from nltk.translate import gleu_score import datasets from datasets import MetricInfo UpperCAmelCase__ = "\\n@misc{wu2016googles,\n title={Google's Neural Machine Translation System: Bridging the Gap between Human and Machine Translation},\n author={Yonghui Wu and Mike Schuster and Zhifeng Chen and Quoc V. Le and Mohammad Norouzi and Wolfgang Macherey\n and Maxim Krikun and Yuan Cao and Qin Gao and Klaus Macherey and Jeff Klingner and Apurva Shah and Melvin\n Johnson and Xiaobing Liu and Łukasz Kaiser and Stephan Gouws and Yoshikiyo Kato and Taku Kudo and Hideto\n Kazawa and Keith Stevens and George Kurian and Nishant Patil and Wei Wang and Cliff Young and\n Jason Smith and Jason Riesa and Alex Rudnick and Oriol Vinyals and Greg Corrado and Macduff Hughes\n and Jeffrey Dean},\n year={2016},\n eprint={1609.08144},\n archivePrefix={arXiv},\n primaryClass={cs.CL}\n}\n" UpperCAmelCase__ = "\\nThe BLEU score has some undesirable properties when used for single\nsentences, as it was designed to be a corpus measure. We therefore\nuse a slightly different score for our RL experiments which we call\nthe 'GLEU score'. For the GLEU score, we record all sub-sequences of\n1, 2, 3 or 4 tokens in output and target sequence (n-grams). We then\ncompute a recall, which is the ratio of the number of matching n-grams\nto the number of total n-grams in the target (ground truth) sequence,\nand a precision, which is the ratio of the number of matching n-grams\nto the number of total n-grams in the generated output sequence. Then\nGLEU score is simply the minimum of recall and precision. This GLEU\nscore's range is always between 0 (no matches) and 1 (all match) and\nit is symmetrical when switching output and target. According to\nour experiments, GLEU score correlates quite well with the BLEU\nmetric on a corpus level but does not have its drawbacks for our per\nsentence reward objective.\n" UpperCAmelCase__ = "\\nComputes corpus-level Google BLEU (GLEU) score of translated segments against one or more references.\nInstead of averaging the sentence level GLEU scores (i.e. macro-average precision), Wu et al. (2016) sum up the matching\ntokens and the max of hypothesis and reference tokens for each sentence, then compute using the aggregate values.\n\nArgs:\n predictions (list of str): list of translations to score.\n Each translation should be tokenized into a list of tokens.\n references (list of list of str): list of lists of references for each translation.\n Each reference should be tokenized into a list of tokens.\n min_len (int): The minimum order of n-gram this function should extract. Defaults to 1.\n max_len (int): The maximum order of n-gram this function should extract. Defaults to 4.\n\nReturns:\n 'google_bleu': google_bleu score\n\nExamples:\n Example 1:\n >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'always',\n ... 'disobeys', 'the', 'commands', 'of', 'the', 'cat']\n >>> ref1a = ['It', 'is', 'the', 'guiding', 'principle', 'which',\n ... 'guarantees', 'the', 'rubber', 'duck', 'forces', 'never',\n ... 'being', 'under', 'the', 'command', 'of', 'the', 'cat']\n\n >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was',\n ... 'interested', 'in', 'world', 'history']\n >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history',\n ... 'because', 'he', 'read', 'the', 'book']\n\n >>> list_of_references = [[ref1a], [ref2a]]\n >>> hypotheses = [hyp1, hyp2]\n >>> google_bleu = datasets.load_metric(\"google_bleu\")\n >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references)\n >>> print(round(results[\"google_bleu\"], 2))\n 0.44\n\n Example 2:\n >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'always',\n ... 'disobeys', 'the', 'commands', 'of', 'the', 'cat']\n >>> ref1a = ['It', 'is', 'the', 'guiding', 'principle', 'which',\n ... 'guarantees', 'the', 'rubber', 'duck', 'forces', 'never',\n ... 'being', 'under', 'the', 'command', 'of', 'the', 'cat']\n >>> ref1b = ['It', 'is', 'a', 'guide', 'to', 'action', 'that',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'will', 'never',\n ... 'heed', 'the', 'cat', 'commands']\n >>> ref1c = ['It', 'is', 'the', 'practical', 'guide', 'for', 'the',\n ... 'rubber', 'duck', 'army', 'never', 'to', 'heed', 'the', 'directions',\n ... 'of', 'the', 'cat']\n\n >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was',\n ... 'interested', 'in', 'world', 'history']\n >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history',\n ... 'because', 'he', 'read', 'the', 'book']\n\n >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]\n >>> hypotheses = [hyp1, hyp2]\n >>> google_bleu = datasets.load_metric(\"google_bleu\")\n >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references)\n >>> print(round(results[\"google_bleu\"], 2))\n 0.61\n\n Example 3:\n >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'always',\n ... 'disobeys', 'the', 'commands', 'of', 'the', 'cat']\n >>> ref1a = ['It', 'is', 'the', 'guiding', 'principle', 'which',\n ... 'guarantees', 'the', 'rubber', 'duck', 'forces', 'never',\n ... 'being', 'under', 'the', 'command', 'of', 'the', 'cat']\n >>> ref1b = ['It', 'is', 'a', 'guide', 'to', 'action', 'that',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'will', 'never',\n ... 'heed', 'the', 'cat', 'commands']\n >>> ref1c = ['It', 'is', 'the', 'practical', 'guide', 'for', 'the',\n ... 'rubber', 'duck', 'army', 'never', 'to', 'heed', 'the', 'directions',\n ... 'of', 'the', 'cat']\n\n >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was',\n ... 'interested', 'in', 'world', 'history']\n >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history',\n ... 'because', 'he', 'read', 'the', 'book']\n\n >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]\n >>> hypotheses = [hyp1, hyp2]\n >>> google_bleu = datasets.load_metric(\"google_bleu\")\n >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references, min_len=2)\n >>> print(round(results[\"google_bleu\"], 2))\n 0.53\n\n Example 4:\n >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'always',\n ... 'disobeys', 'the', 'commands', 'of', 'the', 'cat']\n >>> ref1a = ['It', 'is', 'the', 'guiding', 'principle', 'which',\n ... 'guarantees', 'the', 'rubber', 'duck', 'forces', 'never',\n ... 'being', 'under', 'the', 'command', 'of', 'the', 'cat']\n >>> ref1b = ['It', 'is', 'a', 'guide', 'to', 'action', 'that',\n ... 'ensures', 'that', 'the', 'rubber', 'duck', 'will', 'never',\n ... 'heed', 'the', 'cat', 'commands']\n >>> ref1c = ['It', 'is', 'the', 'practical', 'guide', 'for', 'the',\n ... 'rubber', 'duck', 'army', 'never', 'to', 'heed', 'the', 'directions',\n ... 'of', 'the', 'cat']\n\n >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was',\n ... 'interested', 'in', 'world', 'history']\n >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history',\n ... 'because', 'he', 'read', 'the', 'book']\n\n >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]\n >>> hypotheses = [hyp1, hyp2]\n >>> google_bleu = datasets.load_metric(\"google_bleu\")\n >>> results = google_bleu.compute(predictions=hypotheses,references=list_of_references, min_len=2, max_len=6)\n >>> print(round(results[\"google_bleu\"], 2))\n 0.4\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class __lowerCAmelCase ( datasets.Metric ): def _lowerCamelCase ( self : str) -> MetricInfo: """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': datasets.Sequence(datasets.Value('string' , id='token') , id='sequence'), 'references': datasets.Sequence( datasets.Sequence(datasets.Value('string' , id='token') , id='sequence') , id='references'), }) , ) def _lowerCamelCase ( self : Union[str, Any] , A : List[List[List[str]]] , A : List[List[str]] , A : int = 1 , A : int = 4 , ) -> Dict[str, float]: """simple docstring""" return { "google_bleu": gleu_score.corpus_gleu( list_of_references=A , hypotheses=A , min_len=A , max_len=A) }
339
0
'''simple docstring''' import json import os from functools import lru_cache from typing import List, Optional, Tuple import regex as re from ...tokenization_utils import AddedToken, PreTrainedTokenizer from ...utils import logging SCREAMING_SNAKE_CASE_: Dict =logging.get_logger(__name__) SCREAMING_SNAKE_CASE_: List[Any] ={'vocab_file': 'vocab.json', 'merges_file': 'merges.txt'} SCREAMING_SNAKE_CASE_: Tuple ={ 'vocab_file': { 'allenai/longformer-base-4096': 'https://huggingface.co/allenai/longformer-base-4096/resolve/main/vocab.json', 'allenai/longformer-large-4096': ( 'https://huggingface.co/allenai/longformer-large-4096/resolve/main/vocab.json' ), 'allenai/longformer-large-4096-finetuned-triviaqa': ( 'https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/vocab.json' ), 'allenai/longformer-base-4096-extra.pos.embd.only': ( 'https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/vocab.json' ), 'allenai/longformer-large-4096-extra.pos.embd.only': ( 'https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/vocab.json' ), }, 'merges_file': { 'allenai/longformer-base-4096': 'https://huggingface.co/allenai/longformer-base-4096/resolve/main/merges.txt', 'allenai/longformer-large-4096': ( 'https://huggingface.co/allenai/longformer-large-4096/resolve/main/merges.txt' ), 'allenai/longformer-large-4096-finetuned-triviaqa': ( 'https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/merges.txt' ), 'allenai/longformer-base-4096-extra.pos.embd.only': ( 'https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/merges.txt' ), 'allenai/longformer-large-4096-extra.pos.embd.only': ( 'https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/merges.txt' ), }, } SCREAMING_SNAKE_CASE_: Tuple ={ 'allenai/longformer-base-4096': 40_96, 'allenai/longformer-large-4096': 40_96, 'allenai/longformer-large-4096-finetuned-triviaqa': 40_96, 'allenai/longformer-base-4096-extra.pos.embd.only': 40_96, 'allenai/longformer-large-4096-extra.pos.embd.only': 40_96, } @lru_cache() # Copied from transformers.models.roberta.tokenization_roberta.bytes_to_unicode def lowerCAmelCase_ ( ) -> List[str]: '''simple docstring''' UpperCAmelCase_ = ( list(range(ord("!" ) , ord("~" ) + 1 ) ) + list(range(ord("¡" ) , ord("¬" ) + 1 ) ) + list(range(ord("®" ) , ord("ÿ" ) + 1 ) ) ) UpperCAmelCase_ = bs[:] UpperCAmelCase_ = 0 for b in range(2**8 ): if b not in bs: bs.append(snake_case_ ) cs.append(2**8 + n ) n += 1 UpperCAmelCase_ = [chr(snake_case_ ) for n in cs] return dict(zip(snake_case_ , snake_case_ ) ) def lowerCAmelCase_ ( snake_case_ : Union[str, Any] ) -> int: '''simple docstring''' UpperCAmelCase_ = set() UpperCAmelCase_ = word[0] for char in word[1:]: pairs.add((prev_char, char) ) UpperCAmelCase_ = char return pairs class __A ( UpperCamelCase__ ): a__ : Dict = VOCAB_FILES_NAMES a__ : Union[str, Any] = PRETRAINED_VOCAB_FILES_MAP a__ : Optional[int] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES a__ : Union[str, Any] = ["""input_ids""", """attention_mask"""] def __init__(self : Any , __a : Optional[Any] , __a : Union[str, Any] , __a : List[str]="replace" , __a : List[str]="<s>" , __a : str="</s>" , __a : Dict="</s>" , __a : Tuple="<s>" , __a : Optional[Any]="<unk>" , __a : List[Any]="<pad>" , __a : Dict="<mask>" , __a : Any=False , **__a : int , ): UpperCAmelCase_ = AddedToken(__a , lstrip=__a , rstrip=__a ) if isinstance(__a , __a ) else bos_token UpperCAmelCase_ = AddedToken(__a , lstrip=__a , rstrip=__a ) if isinstance(__a , __a ) else eos_token UpperCAmelCase_ = AddedToken(__a , lstrip=__a , rstrip=__a ) if isinstance(__a , __a ) else sep_token UpperCAmelCase_ = AddedToken(__a , lstrip=__a , rstrip=__a ) if isinstance(__a , __a ) else cls_token UpperCAmelCase_ = AddedToken(__a , lstrip=__a , rstrip=__a ) if isinstance(__a , __a ) else unk_token UpperCAmelCase_ = AddedToken(__a , lstrip=__a , rstrip=__a ) if isinstance(__a , __a ) else pad_token # Mask token behave like a normal word, i.e. include the space before it UpperCAmelCase_ = AddedToken(__a , lstrip=__a , rstrip=__a ) if isinstance(__a , __a ) else mask_token super().__init__( errors=__a , bos_token=__a , eos_token=__a , unk_token=__a , sep_token=__a , cls_token=__a , pad_token=__a , mask_token=__a , add_prefix_space=__a , **__a , ) with open(__a , encoding="utf-8" ) as vocab_handle: UpperCAmelCase_ = json.load(__a ) UpperCAmelCase_ = {v: k for k, v in self.encoder.items()} UpperCAmelCase_ = errors # how to handle errors in decoding UpperCAmelCase_ = bytes_to_unicode() UpperCAmelCase_ = {v: k for k, v in self.byte_encoder.items()} with open(__a , encoding="utf-8" ) as merges_handle: UpperCAmelCase_ = merges_handle.read().split("\n" )[1:-1] UpperCAmelCase_ = [tuple(merge.split() ) for merge in bpe_merges] UpperCAmelCase_ = dict(zip(__a , range(len(__a ) ) ) ) UpperCAmelCase_ = {} UpperCAmelCase_ = add_prefix_space # Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions UpperCAmelCase_ = re.compile(r"'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+" ) @property def _lowercase (self : str ): return len(self.encoder ) def _lowercase (self : Dict ): return dict(self.encoder , **self.added_tokens_encoder ) def _lowercase (self : Any , __a : Any ): if token in self.cache: return self.cache[token] UpperCAmelCase_ = tuple(__a ) UpperCAmelCase_ = get_pairs(__a ) if not pairs: return token while True: UpperCAmelCase_ = min(__a , key=lambda __a : self.bpe_ranks.get(__a , float("inf" ) ) ) if bigram not in self.bpe_ranks: break UpperCAmelCase_ , UpperCAmelCase_ = bigram UpperCAmelCase_ = [] UpperCAmelCase_ = 0 while i < len(__a ): try: UpperCAmelCase_ = word.index(__a , __a ) except ValueError: new_word.extend(word[i:] ) break else: new_word.extend(word[i:j] ) UpperCAmelCase_ = j if word[i] == first and i < len(__a ) - 1 and word[i + 1] == second: new_word.append(first + second ) i += 2 else: new_word.append(word[i] ) i += 1 UpperCAmelCase_ = tuple(__a ) UpperCAmelCase_ = new_word if len(__a ) == 1: break else: UpperCAmelCase_ = get_pairs(__a ) UpperCAmelCase_ = " ".join(__a ) UpperCAmelCase_ = word return word def _lowercase (self : Tuple , __a : Tuple ): UpperCAmelCase_ = [] for token in re.findall(self.pat , __a ): UpperCAmelCase_ = "".join( self.byte_encoder[b] for b in token.encode("utf-8" ) ) # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case) bpe_tokens.extend(bpe_token for bpe_token in self.bpe(__a ).split(" " ) ) return bpe_tokens def _lowercase (self : Optional[Any] , __a : int ): return self.encoder.get(__a , self.encoder.get(self.unk_token ) ) def _lowercase (self : str , __a : Optional[Any] ): return self.decoder.get(__a ) def _lowercase (self : Dict , __a : Dict ): UpperCAmelCase_ = "".join(__a ) UpperCAmelCase_ = bytearray([self.byte_decoder[c] for c in text] ).decode("utf-8" , errors=self.errors ) return text def _lowercase (self : Union[str, Any] , __a : str , __a : Optional[str] = None ): if not os.path.isdir(__a ): logger.error(f"""Vocabulary path ({save_directory}) should be a directory""" ) return UpperCAmelCase_ = os.path.join( __a , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] ) UpperCAmelCase_ = os.path.join( __a , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["merges_file"] ) with open(__a , "w" , encoding="utf-8" ) as f: f.write(json.dumps(self.encoder , indent=2 , sort_keys=__a , ensure_ascii=__a ) + "\n" ) UpperCAmelCase_ = 0 with open(__a , "w" , encoding="utf-8" ) as writer: writer.write("#version: 0.2\n" ) for bpe_tokens, token_index in sorted(self.bpe_ranks.items() , key=lambda __a : kv[1] ): if index != token_index: logger.warning( f"""Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.""" " Please check that the tokenizer is not corrupted!" ) UpperCAmelCase_ = token_index writer.write(" ".join(__a ) + "\n" ) index += 1 return vocab_file, merge_file def _lowercase (self : Optional[Any] , __a : List[int] , __a : Optional[List[int]] = None ): if token_ids_a is None: return [self.cls_token_id] + token_ids_a + [self.sep_token_id] UpperCAmelCase_ = [self.cls_token_id] UpperCAmelCase_ = [self.sep_token_id] return cls + token_ids_a + sep + sep + token_ids_a + sep def _lowercase (self : List[Any] , __a : List[int] , __a : Optional[List[int]] = None , __a : bool = False ): if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=__a , token_ids_a=__a , already_has_special_tokens=__a ) if token_ids_a is None: return [1] + ([0] * len(__a )) + [1] return [1] + ([0] * len(__a )) + [1, 1] + ([0] * len(__a )) + [1] def _lowercase (self : int , __a : List[int] , __a : Optional[List[int]] = None ): UpperCAmelCase_ = [self.sep_token_id] UpperCAmelCase_ = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0] def _lowercase (self : List[Any] , __a : Tuple , __a : Optional[Any]=False , **__a : Dict ): UpperCAmelCase_ = kwargs.pop("add_prefix_space" , self.add_prefix_space ) if (is_split_into_words or add_prefix_space) and (len(__a ) > 0 and not text[0].isspace()): UpperCAmelCase_ = " " + text return (text, kwargs)
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_sentencepiece_available, is_tf_available, is_tokenizers_available, is_torch_available, ) if is_sentencepiece_available(): from ..ta.tokenization_ta import TaTokenizer else: from ...utils.dummy_sentencepiece_objects import TaTokenizer UpperCAmelCase__ = TaTokenizer if is_tokenizers_available(): from ..ta.tokenization_ta_fast import TaTokenizerFast else: from ...utils.dummy_tokenizers_objects import TaTokenizerFast UpperCAmelCase__ = TaTokenizerFast UpperCAmelCase__ = {"configuration_mt5": ["MT5Config", "MT5OnnxConfig"]} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase__ = [ "MT5EncoderModel", "MT5ForConditionalGeneration", "MT5ForQuestionAnswering", "MT5Model", "MT5PreTrainedModel", "MT5Stack", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase__ = ["TFMT5EncoderModel", "TFMT5ForConditionalGeneration", "TFMT5Model"] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCAmelCase__ = ["FlaxMT5EncoderModel", "FlaxMT5ForConditionalGeneration", "FlaxMT5Model"] if TYPE_CHECKING: from .configuration_mta import MTaConfig, MTaOnnxConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_mta import ( MTaEncoderModel, MTaForConditionalGeneration, MTaForQuestionAnswering, MTaModel, MTaPreTrainedModel, MTaStack, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_mta import TFMTaEncoderModel, TFMTaForConditionalGeneration, TFMTaModel try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_mta import FlaxMTaEncoderModel, FlaxMTaForConditionalGeneration, FlaxMTaModel else: import sys UpperCAmelCase__ = _LazyModule( __name__, globals()["__file__"], _import_structure, extra_objects={"MT5Tokenizer": MTaTokenizer, "MT5TokenizerFast": MTaTokenizerFast}, module_spec=__spec__, )
339
0
'''simple docstring''' import string def _SCREAMING_SNAKE_CASE (A ) -> str: """simple docstring""" lowercase__ = '''''' for i in sequence: lowercase__ = ord(A ) if 65 <= extract <= 90: output += chr(155 - extract ) elif 97 <= extract <= 122: output += chr(219 - extract ) else: output += i return output def _SCREAMING_SNAKE_CASE (A ) -> str: """simple docstring""" lowercase__ = string.ascii_letters lowercase__ = string.ascii_lowercase[::-1] + string.ascii_uppercase[::-1] return "".join( letters_reversed[letters.index(A )] if c in letters else c for c in sequence ) def _SCREAMING_SNAKE_CASE () -> None: """simple docstring""" from timeit import timeit print('''Running performance benchmarks...''' ) lowercase__ = '''from string import printable ; from __main__ import atbash, atbash_slow''' print(f"> atbash_slow(): {timeit('atbash_slow(printable)' , setup=A )} seconds" ) print(f"> atbash(): {timeit('atbash(printable)' , setup=A )} seconds" ) if __name__ == "__main__": for example in ("ABCDEFGH", "123GGjj", "testStringtest", "with space"): print(f"""{example} encrypted in atbash: {atbash(example)}""") benchmark()
2
from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCAmelCase__ = logging.get_logger(__name__) UpperCAmelCase__ = { "s-JoL/Open-Llama-V1": "https://huggingface.co/s-JoL/Open-Llama-V1/blob/main/config.json", } class __lowerCAmelCase ( A ): UpperCamelCase = '''open-llama''' def __init__( self : str , A : List[Any]=10_00_00 , A : Tuple=40_96 , A : Tuple=1_10_08 , A : List[str]=32 , A : Tuple=32 , A : Optional[Any]="silu" , A : int=20_48 , A : Optional[Any]=0.0_2 , A : Dict=1E-6 , A : Optional[Any]=True , A : List[Any]=0 , A : Dict=1 , A : int=2 , A : Dict=False , A : Optional[int]=True , A : List[Any]=0.1 , A : str=0.1 , A : Dict=True , A : Optional[Any]=True , A : Dict=None , **A : Union[str, Any] , ) -> Dict: """simple docstring""" _UpperCAmelCase = vocab_size _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = hidden_size _UpperCAmelCase = intermediate_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = hidden_act _UpperCAmelCase = initializer_range _UpperCAmelCase = rms_norm_eps _UpperCAmelCase = use_cache _UpperCAmelCase = kwargs.pop( 'use_memorry_efficient_attention' , A) _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_dropout_prob _UpperCAmelCase = use_stable_embedding _UpperCAmelCase = shared_input_output_embedding _UpperCAmelCase = rope_scaling self._rope_scaling_validation() super().__init__( pad_token_id=A , bos_token_id=A , eos_token_id=A , tie_word_embeddings=A , **A , ) def _lowerCamelCase ( self : List[str]) -> Union[str, Any]: """simple docstring""" if self.rope_scaling is None: return if not isinstance(self.rope_scaling , A) or len(self.rope_scaling) != 2: raise ValueError( '`rope_scaling` must be a dictionary with with two fields, `name` and `factor`, ' F"got {self.rope_scaling}") _UpperCAmelCase = self.rope_scaling.get('type' , A) _UpperCAmelCase = self.rope_scaling.get('factor' , A) if rope_scaling_type is None or rope_scaling_type not in ["linear", "dynamic"]: raise ValueError( F"`rope_scaling`'s name field must be one of ['linear', 'dynamic'], got {rope_scaling_type}") if rope_scaling_factor is None or not isinstance(A , A) or rope_scaling_factor <= 1.0: raise ValueError(F"`rope_scaling`'s factor field must be an float > 1, got {rope_scaling_factor}")
339
0
'''simple docstring''' import os import random import sys from . import cryptomath_module as cryptomath from . import rabin_miller lowercase : Union[str, Any] = 3 def lowerCAmelCase_ ( snake_case__ ): '''simple docstring''' print('''Generating primitive root of p''' ) while True: A : Optional[Any] = random.randrange(3 , snake_case__ ) if pow(snake_case__ , 2 , snake_case__ ) == 1: continue if pow(snake_case__ , snake_case__ , snake_case__ ) == 1: continue return g def lowerCAmelCase_ ( snake_case__ ): '''simple docstring''' print('''Generating prime p...''' ) A : int = rabin_miller.generate_large_prime(snake_case__ ) # select large prime number. A : List[str] = primitive_root(snake_case__ ) # one primitive root on modulo p. A : Union[str, Any] = random.randrange(3 , snake_case__ ) # private_key -> have to be greater than 2 for safety. A : str = cryptomath.find_mod_inverse(pow(snake_case__ , snake_case__ , snake_case__ ) , snake_case__ ) A : Dict = (key_size, e_a, e_a, p) A : Optional[int] = (key_size, d) return public_key, private_key def lowerCAmelCase_ ( snake_case__ , snake_case__ ): '''simple docstring''' if os.path.exists(F'{name}_pubkey.txt' ) or os.path.exists(F'{name}_privkey.txt' ): print('''\nWARNING:''' ) print( F'"{name}_pubkey.txt" or "{name}_privkey.txt" already exists. \n' '''Use a different name or delete these files and re-run this program.''' ) sys.exit() A, A : int = generate_key(snake_case__ ) print(F'\nWriting public key to file {name}_pubkey.txt...' ) with open(F'{name}_pubkey.txt' , '''w''' ) as fo: fo.write(F'{public_key[0]},{public_key[1]},{public_key[2]},{public_key[3]}' ) print(F'Writing private key to file {name}_privkey.txt...' ) with open(F'{name}_privkey.txt' , '''w''' ) as fo: fo.write(F'{private_key[0]},{private_key[1]}' ) def lowerCAmelCase_ ( ): '''simple docstring''' print('''Making key files...''' ) make_key_files('''elgamal''' , 2048 ) print('''Key files generation successful''' ) if __name__ == "__main__": main()
3
def A ( _UpperCAmelCase : str ) -> bool: '''simple docstring''' return credit_card_number.startswith(('34', '35', '37', '4', '5', '6') ) def A ( _UpperCAmelCase : str ) -> bool: '''simple docstring''' _UpperCAmelCase = credit_card_number _UpperCAmelCase = 0 _UpperCAmelCase = len(_UpperCAmelCase ) - 2 for i in range(_UpperCAmelCase , -1 , -2 ): # double the value of every second digit _UpperCAmelCase = int(cc_number[i] ) digit *= 2 # If doubling of a number results in a two digit number # i.e greater than 9(e.g., 6 × 2 = 12), # then add the digits of the product (e.g., 12: 1 + 2 = 3, 15: 1 + 5 = 6), # to get a single digit number. if digit > 9: digit %= 10 digit += 1 _UpperCAmelCase = cc_number[:i] + str(_UpperCAmelCase ) + cc_number[i + 1 :] total += digit # Sum up the remaining digits for i in range(len(_UpperCAmelCase ) - 1 , -1 , -2 ): total += int(cc_number[i] ) return total % 10 == 0 def A ( _UpperCAmelCase : str ) -> bool: '''simple docstring''' _UpperCAmelCase = F"{credit_card_number} is an invalid credit card number because" if not credit_card_number.isdigit(): print(F"{error_message} it has nonnumerical characters." ) return False if not 13 <= len(_UpperCAmelCase ) <= 16: print(F"{error_message} of its length." ) return False if not validate_initial_digits(_UpperCAmelCase ): print(F"{error_message} of its first two digits." ) return False if not luhn_validation(_UpperCAmelCase ): print(F"{error_message} it fails the Luhn check." ) return False print(F"{credit_card_number} is a valid credit card number." ) return True if __name__ == "__main__": import doctest doctest.testmod() validate_credit_card_number("4111111111111111") validate_credit_card_number("32323")
339
0
'''simple docstring''' import logging import os import sys from dataclasses import dataclass, field from itertools import chain from typing import Optional, Union import datasets import numpy as np import torch from datasets import load_dataset import transformers from transformers import ( AutoConfig, AutoModelForMultipleChoice, AutoTokenizer, HfArgumentParser, Trainer, TrainingArguments, default_data_collator, set_seed, ) from transformers.tokenization_utils_base import PreTrainedTokenizerBase from transformers.trainer_utils import get_last_checkpoint from transformers.utils import PaddingStrategy, check_min_version, send_example_telemetry # Will error if the minimal version of Transformers is not installed. Remove at your own risks. check_min_version("""4.31.0""") __snake_case =logging.getLogger(__name__) @dataclass class UpperCAmelCase_ : lowerCamelCase : str = field( metadata={'''help''': '''Path to pretrained model or model identifier from huggingface.co/models'''} ) lowerCamelCase : Optional[str] = field( default=__lowercase , metadata={'''help''': '''Pretrained config name or path if not the same as model_name'''} ) lowerCamelCase : Optional[str] = field( default=__lowercase , metadata={'''help''': '''Pretrained tokenizer name or path if not the same as model_name'''} ) lowerCamelCase : Optional[str] = field( default=__lowercase , metadata={'''help''': '''Where do you want to store the pretrained models downloaded from huggingface.co'''} , ) lowerCamelCase : bool = field( default=__lowercase , metadata={'''help''': '''Whether to use one of the fast tokenizer (backed by the tokenizers library) or not.'''} , ) lowerCamelCase : str = field( default='''main''' , metadata={'''help''': '''The specific model version to use (can be a branch name, tag name or commit id).'''} , ) lowerCamelCase : bool = field( default=__lowercase , metadata={ '''help''': ( '''Will use the token generated when running `huggingface-cli login` (necessary to use this script ''' '''with private models).''' ) } , ) @dataclass class UpperCAmelCase_ : lowerCamelCase : Optional[str] = field(default=__lowercase , metadata={'''help''': '''The input training data file (a text file).'''} ) lowerCamelCase : Optional[str] = field( default=__lowercase , metadata={'''help''': '''An optional input evaluation data file to evaluate the perplexity on (a text file).'''} , ) lowerCamelCase : bool = field( default=__lowercase , metadata={'''help''': '''Overwrite the cached training and evaluation sets'''} ) lowerCamelCase : Optional[int] = field( default=__lowercase , metadata={'''help''': '''The number of processes to use for the preprocessing.'''} , ) lowerCamelCase : Optional[int] = field( default=__lowercase , metadata={ '''help''': ( '''The maximum total input sequence length after tokenization. If passed, sequences longer ''' '''than this will be truncated, sequences shorter will be padded.''' ) } , ) lowerCamelCase : bool = field( default=__lowercase , metadata={ '''help''': ( '''Whether to pad all samples to the maximum sentence length. ''' '''If False, will pad the samples dynamically when batching to the maximum length in the batch. More ''' '''efficient on GPU but very bad for TPU.''' ) } , ) lowerCamelCase : Optional[int] = field( default=__lowercase , metadata={ '''help''': ( '''For debugging purposes or quicker training, truncate the number of training examples to this ''' '''value if set.''' ) } , ) lowerCamelCase : Optional[int] = field( default=__lowercase , metadata={ '''help''': ( '''For debugging purposes or quicker training, truncate the number of evaluation examples to this ''' '''value if set.''' ) } , ) def __UpperCAmelCase ( self : List[str] ) -> str: if self.train_file is not None: lowerCAmelCase = self.train_file.split('.' )[-1] assert extension in ["csv", "json"], "`train_file` should be a csv or a json file." if self.validation_file is not None: lowerCAmelCase = self.validation_file.split('.' )[-1] assert extension in ["csv", "json"], "`validation_file` should be a csv or a json file." @dataclass class UpperCAmelCase_ : lowerCamelCase : PreTrainedTokenizerBase lowerCamelCase : Union[bool, str, PaddingStrategy] = True lowerCamelCase : Optional[int] = None lowerCamelCase : Optional[int] = None def __call__( self : Optional[Any] , UpperCAmelCase__ : Union[str, Any] ) -> str: lowerCAmelCase = 'label' if 'label' in features[0].keys() else 'labels' lowerCAmelCase = [feature.pop(UpperCAmelCase__ ) for feature in features] lowerCAmelCase = len(UpperCAmelCase__ ) lowerCAmelCase = len(features[0]['input_ids'] ) lowerCAmelCase = [ [{k: v[i] for k, v in feature.items()} for i in range(UpperCAmelCase__ )] for feature in features ] lowerCAmelCase = list(chain(*UpperCAmelCase__ ) ) lowerCAmelCase = self.tokenizer.pad( UpperCAmelCase__ , padding=self.padding , max_length=self.max_length , pad_to_multiple_of=self.pad_to_multiple_of , return_tensors='pt' , ) # Un-flatten lowerCAmelCase = {k: v.view(UpperCAmelCase__ , UpperCAmelCase__ , -1 ) for k, v in batch.items()} # Add back labels lowerCAmelCase = torch.tensor(UpperCAmelCase__ , dtype=torch.intaa ) return batch def a_ ( ): # See all possible arguments in src/transformers/training_args.py # or by passing the --help flag to this script. # We now keep distinct sets of args, for a cleaner separation of concerns. lowerCAmelCase = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments) ) if len(sys.argv ) == 2 and sys.argv[1].endswith('.json' ): # If we pass only one argument to the script and it's the path to a json file, # let's parse it to get our arguments. lowerCAmelCase , lowerCAmelCase , lowerCAmelCase = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1] ) ) else: lowerCAmelCase , lowerCAmelCase , lowerCAmelCase = parser.parse_args_into_dataclasses() # Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The # information sent is the one passed as arguments along with your Python/PyTorch versions. send_example_telemetry('run_swag' , lowerCamelCase , lowerCamelCase ) # Setup logging logging.basicConfig( format='%(asctime)s - %(levelname)s - %(name)s - %(message)s' , datefmt='%m/%d/%Y %H:%M:%S' , handlers=[logging.StreamHandler(sys.stdout )] , ) if training_args.should_log: # The default of training_args.log_level is passive, so we set log level at info here to have that default. transformers.utils.logging.set_verbosity_info() lowerCAmelCase = training_args.get_process_log_level() logger.setLevel(lowerCamelCase ) datasets.utils.logging.set_verbosity(lowerCamelCase ) transformers.utils.logging.set_verbosity(lowerCamelCase ) transformers.utils.logging.enable_default_handler() transformers.utils.logging.enable_explicit_format() # Log on each process the small summary: logger.warning( f'''Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}''' + f'''distributed training: {bool(training_args.local_rank != -1 )}, 16-bits training: {training_args.fpaa}''' ) logger.info(f'''Training/evaluation parameters {training_args}''' ) # Detecting last checkpoint. lowerCAmelCase = None if os.path.isdir(training_args.output_dir ) and training_args.do_train and not training_args.overwrite_output_dir: lowerCAmelCase = get_last_checkpoint(training_args.output_dir ) if last_checkpoint is None and len(os.listdir(training_args.output_dir ) ) > 0: raise ValueError( f'''Output directory ({training_args.output_dir}) already exists and is not empty. ''' 'Use --overwrite_output_dir to overcome.' ) elif last_checkpoint is not None and training_args.resume_from_checkpoint is None: logger.info( f'''Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change ''' 'the `--output_dir` or add `--overwrite_output_dir` to train from scratch.' ) # Set seed before initializing model. set_seed(training_args.seed ) # Get the datasets: you can either provide your own CSV/JSON/TXT training and evaluation files (see below) # or just provide the name of one of the public datasets available on the hub at https://huggingface.co/datasets/ # (the dataset will be downloaded automatically from the datasets Hub). # For CSV/JSON files, this script will use the column called 'text' or the first column if no column called # 'text' is found. You can easily tweak this behavior (see below). # In distributed training, the load_dataset function guarantee that only one local process can concurrently # download the dataset. if data_args.train_file is not None or data_args.validation_file is not None: lowerCAmelCase = {} if data_args.train_file is not None: lowerCAmelCase = data_args.train_file if data_args.validation_file is not None: lowerCAmelCase = data_args.validation_file lowerCAmelCase = data_args.train_file.split('.' )[-1] lowerCAmelCase = load_dataset( lowerCamelCase , data_files=lowerCamelCase , cache_dir=model_args.cache_dir , use_auth_token=True if model_args.use_auth_token else None , ) else: # Downloading and loading the swag dataset from the hub. lowerCAmelCase = load_dataset( 'swag' , 'regular' , cache_dir=model_args.cache_dir , use_auth_token=True if model_args.use_auth_token else None , ) # See more about loading any type of standard or custom dataset (from files, python dict, pandas DataFrame, etc) at # https://huggingface.co/docs/datasets/loading_datasets.html. # Load pretrained model and tokenizer # Distributed training: # The .from_pretrained methods guarantee that only one local process can concurrently # download model & vocab. lowerCAmelCase = AutoConfig.from_pretrained( model_args.config_name if model_args.config_name else model_args.model_name_or_path , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , ) lowerCAmelCase = AutoTokenizer.from_pretrained( model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path , cache_dir=model_args.cache_dir , use_fast=model_args.use_fast_tokenizer , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , ) lowerCAmelCase = AutoModelForMultipleChoice.from_pretrained( model_args.model_name_or_path , from_tf=bool('.ckpt' in model_args.model_name_or_path ) , config=lowerCamelCase , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , ) # When using your own dataset or a different dataset from swag, you will probably need to change this. lowerCAmelCase = [f'''ending{i}''' for i in range(4 )] lowerCAmelCase = 'sent1' lowerCAmelCase = 'sent2' if data_args.max_seq_length is None: lowerCAmelCase = tokenizer.model_max_length if max_seq_length > 1024: logger.warning( 'The chosen tokenizer supports a `model_max_length` that is longer than the default `block_size` value' ' of 1024. If you would like to use a longer `block_size` up to `tokenizer.model_max_length` you can' ' override this default with `--block_size xxx`.' ) lowerCAmelCase = 1024 else: if data_args.max_seq_length > tokenizer.model_max_length: logger.warning( f'''The max_seq_length passed ({data_args.max_seq_length}) is larger than the maximum length for the''' f'''model ({tokenizer.model_max_length}). Using max_seq_length={tokenizer.model_max_length}.''' ) lowerCAmelCase = min(data_args.max_seq_length , tokenizer.model_max_length ) # Preprocessing the datasets. def preprocess_function(lowerCamelCase : Optional[Any] ): lowerCAmelCase = [[context] * 4 for context in examples[context_name]] lowerCAmelCase = examples[question_header_name] lowerCAmelCase = [ [f'''{header} {examples[end][i]}''' for end in ending_names] for i, header in enumerate(lowerCamelCase ) ] # Flatten out lowerCAmelCase = list(chain(*lowerCamelCase ) ) lowerCAmelCase = list(chain(*lowerCamelCase ) ) # Tokenize lowerCAmelCase = tokenizer( lowerCamelCase , lowerCamelCase , truncation=lowerCamelCase , max_length=lowerCamelCase , padding='max_length' if data_args.pad_to_max_length else False , ) # Un-flatten return {k: [v[i : i + 4] for i in range(0 , len(lowerCamelCase ) , 4 )] for k, v in tokenized_examples.items()} if training_args.do_train: if "train" not in raw_datasets: raise ValueError('--do_train requires a train dataset' ) lowerCAmelCase = raw_datasets['train'] if data_args.max_train_samples is not None: lowerCAmelCase = min(len(lowerCamelCase ) , data_args.max_train_samples ) lowerCAmelCase = train_dataset.select(range(lowerCamelCase ) ) with training_args.main_process_first(desc='train dataset map pre-processing' ): lowerCAmelCase = train_dataset.map( lowerCamelCase , batched=lowerCamelCase , num_proc=data_args.preprocessing_num_workers , load_from_cache_file=not data_args.overwrite_cache , ) if training_args.do_eval: if "validation" not in raw_datasets: raise ValueError('--do_eval requires a validation dataset' ) lowerCAmelCase = raw_datasets['validation'] if data_args.max_eval_samples is not None: lowerCAmelCase = min(len(lowerCamelCase ) , data_args.max_eval_samples ) lowerCAmelCase = eval_dataset.select(range(lowerCamelCase ) ) with training_args.main_process_first(desc='validation dataset map pre-processing' ): lowerCAmelCase = eval_dataset.map( lowerCamelCase , batched=lowerCamelCase , num_proc=data_args.preprocessing_num_workers , load_from_cache_file=not data_args.overwrite_cache , ) # Data collator lowerCAmelCase = ( default_data_collator if data_args.pad_to_max_length else DataCollatorForMultipleChoice(tokenizer=lowerCamelCase , pad_to_multiple_of=8 if training_args.fpaa else None ) ) # Metric def compute_metrics(lowerCamelCase : List[Any] ): lowerCAmelCase , lowerCAmelCase = eval_predictions lowerCAmelCase = np.argmax(lowerCamelCase , axis=1 ) return {"accuracy": (preds == label_ids).astype(np.floataa ).mean().item()} # Initialize our Trainer lowerCAmelCase = Trainer( model=lowerCamelCase , args=lowerCamelCase , train_dataset=train_dataset if training_args.do_train else None , eval_dataset=eval_dataset if training_args.do_eval else None , tokenizer=lowerCamelCase , data_collator=lowerCamelCase , compute_metrics=lowerCamelCase , ) # Training if training_args.do_train: lowerCAmelCase = None if training_args.resume_from_checkpoint is not None: lowerCAmelCase = training_args.resume_from_checkpoint elif last_checkpoint is not None: lowerCAmelCase = last_checkpoint lowerCAmelCase = trainer.train(resume_from_checkpoint=lowerCamelCase ) trainer.save_model() # Saves the tokenizer too for easy upload lowerCAmelCase = train_result.metrics lowerCAmelCase = ( data_args.max_train_samples if data_args.max_train_samples is not None else len(lowerCamelCase ) ) lowerCAmelCase = min(lowerCamelCase , len(lowerCamelCase ) ) trainer.log_metrics('train' , lowerCamelCase ) trainer.save_metrics('train' , lowerCamelCase ) trainer.save_state() # Evaluation if training_args.do_eval: logger.info('*** Evaluate ***' ) lowerCAmelCase = trainer.evaluate() lowerCAmelCase = data_args.max_eval_samples if data_args.max_eval_samples is not None else len(lowerCamelCase ) lowerCAmelCase = min(lowerCamelCase , len(lowerCamelCase ) ) trainer.log_metrics('eval' , lowerCamelCase ) trainer.save_metrics('eval' , lowerCamelCase ) lowerCAmelCase = { 'finetuned_from': model_args.model_name_or_path, 'tasks': 'multiple-choice', 'dataset_tags': 'swag', 'dataset_args': 'regular', 'dataset': 'SWAG', 'language': 'en', } if training_args.push_to_hub: trainer.push_to_hub(**lowerCamelCase ) else: trainer.create_model_card(**lowerCamelCase ) def a_ ( lowerCamelCase : Optional[Any] ): # For xla_spawn (TPUs) main() if __name__ == "__main__": main()
4
from functools import reduce UpperCAmelCase__ = ( "73167176531330624919225119674426574742355349194934" "96983520312774506326239578318016984801869478851843" "85861560789112949495459501737958331952853208805511" "12540698747158523863050715693290963295227443043557" "66896648950445244523161731856403098711121722383113" "62229893423380308135336276614282806444486645238749" "30358907296290491560440772390713810515859307960866" "70172427121883998797908792274921901699720888093776" "65727333001053367881220235421809751254540594752243" "52584907711670556013604839586446706324415722155397" "53697817977846174064955149290862569321978468622482" "83972241375657056057490261407972968652414535100474" "82166370484403199890008895243450658541227588666881" "16427171479924442928230863465674813919123162824586" "17866458359124566529476545682848912883142607690042" "24219022671055626321111109370544217506941658960408" "07198403850962455444362981230987879927244284909188" "84580156166097919133875499200524063689912560717606" "05886116467109405077541002256983155200055935729725" "71636269561882670428252483600823257530420752963450" ) def A ( _UpperCAmelCase : str = N ) -> int: '''simple docstring''' return max( # mypy cannot properly interpret reduce int(reduce(lambda _UpperCAmelCase , _UpperCAmelCase : str(int(_UpperCAmelCase ) * int(_UpperCAmelCase ) ) , n[i : i + 13] ) ) for i in range(len(_UpperCAmelCase ) - 12 ) ) if __name__ == "__main__": print(f"""{solution() = }""")
339
0
class lowerCamelCase__ : def __init__(self ) -> Tuple: _lowercase ='''''' _lowercase ='''''' _lowercase =[] def __A (self , UpperCAmelCase , UpperCAmelCase ) -> int: if m == -1: return n + 1 elif n == -1: return m + 1 elif self.dp[m][n] > -1: return self.dp[m][n] else: if self.worda[m] == self.worda[n]: _lowercase =self.__min_dist_top_down_dp(m - 1 , n - 1 ) else: _lowercase =self.__min_dist_top_down_dp(UpperCAmelCase , n - 1 ) _lowercase =self.__min_dist_top_down_dp(m - 1 , UpperCAmelCase ) _lowercase =self.__min_dist_top_down_dp(m - 1 , n - 1 ) _lowercase =1 + min(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) return self.dp[m][n] def __A (self , UpperCAmelCase , UpperCAmelCase ) -> int: _lowercase =worda _lowercase =worda _lowercase =[[-1 for _ in range(len(UpperCAmelCase ) )] for _ in range(len(UpperCAmelCase ) )] return self.__min_dist_top_down_dp(len(UpperCAmelCase ) - 1 , len(UpperCAmelCase ) - 1 ) def __A (self , UpperCAmelCase , UpperCAmelCase ) -> int: _lowercase =worda _lowercase =worda _lowercase =len(UpperCAmelCase ) _lowercase =len(UpperCAmelCase ) _lowercase =[[0 for _ in range(n + 1 )] for _ in range(m + 1 )] for i in range(m + 1 ): for j in range(n + 1 ): if i == 0: # first string is empty _lowercase =j elif j == 0: # second string is empty _lowercase =i elif worda[i - 1] == worda[j - 1]: # last characters are equal _lowercase =self.dp[i - 1][j - 1] else: _lowercase =self.dp[i][j - 1] _lowercase =self.dp[i - 1][j] _lowercase =self.dp[i - 1][j - 1] _lowercase =1 + min(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) return self.dp[m][n] if __name__ == "__main__": UpperCAmelCase__ = EditDistance() print('''****************** Testing Edit Distance DP Algorithm ******************''') print() UpperCAmelCase__ = input('''Enter the first string: ''').strip() UpperCAmelCase__ = input('''Enter the second string: ''').strip() print() print(f'''The minimum edit distance is: {solver.min_dist_top_down(Sa, Sa)}''') print(f'''The minimum edit distance is: {solver.min_dist_bottom_up(Sa, Sa)}''') print() print('''*************** End of Testing Edit Distance DP Algorithm ***************''')
5
from __future__ import annotations from collections.abc import Callable UpperCAmelCase__ = list[list[float | int]] def A ( _UpperCAmelCase : Matrix , _UpperCAmelCase : Matrix ) -> Matrix: '''simple docstring''' _UpperCAmelCase = len(_UpperCAmelCase ) _UpperCAmelCase = [[0 for _ in range(size + 1 )] for _ in range(_UpperCAmelCase )] _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 for row in range(_UpperCAmelCase ): for col in range(_UpperCAmelCase ): _UpperCAmelCase = matrix[row][col] _UpperCAmelCase = vector[row][0] _UpperCAmelCase = 0 _UpperCAmelCase = 0 while row < size and col < size: # pivoting _UpperCAmelCase = max((abs(augmented[rowa][col] ), rowa) for rowa in range(_UpperCAmelCase , _UpperCAmelCase ) )[ 1 ] if augmented[pivot_row][col] == 0: col += 1 continue else: _UpperCAmelCase , _UpperCAmelCase = augmented[pivot_row], augmented[row] for rowa in range(row + 1 , _UpperCAmelCase ): _UpperCAmelCase = augmented[rowa][col] / augmented[row][col] _UpperCAmelCase = 0 for cola in range(col + 1 , size + 1 ): augmented[rowa][cola] -= augmented[row][cola] * ratio row += 1 col += 1 # back substitution for col in range(1 , _UpperCAmelCase ): for row in range(_UpperCAmelCase ): _UpperCAmelCase = augmented[row][col] / augmented[col][col] for cola in range(_UpperCAmelCase , size + 1 ): augmented[row][cola] -= augmented[col][cola] * ratio # round to get rid of numbers like 2.000000000000004 return [ [round(augmented[row][size] / augmented[row][row] , 10 )] for row in range(_UpperCAmelCase ) ] def A ( _UpperCAmelCase : list[int] ) -> Callable[[int], int]: '''simple docstring''' _UpperCAmelCase = len(_UpperCAmelCase ) _UpperCAmelCase = [[0 for _ in range(_UpperCAmelCase )] for _ in range(_UpperCAmelCase )] _UpperCAmelCase = [[0] for _ in range(_UpperCAmelCase )] _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 _UpperCAmelCase = 42 for x_val, y_val in enumerate(_UpperCAmelCase ): for col in range(_UpperCAmelCase ): _UpperCAmelCase = (x_val + 1) ** (size - col - 1) _UpperCAmelCase = y_val _UpperCAmelCase = solve(_UpperCAmelCase , _UpperCAmelCase ) def interpolated_func(_UpperCAmelCase : int ) -> int: return sum( round(coeffs[x_val][0] ) * (var ** (size - x_val - 1)) for x_val in range(_UpperCAmelCase ) ) return interpolated_func def A ( _UpperCAmelCase : int ) -> int: '''simple docstring''' return ( 1 - variable + variable**2 - variable**3 + variable**4 - variable**5 + variable**6 - variable**7 + variable**8 - variable**9 + variable**10 ) def A ( _UpperCAmelCase : Callable[[int], int] = question_function , _UpperCAmelCase : int = 10 ) -> int: '''simple docstring''' _UpperCAmelCase = [func(_UpperCAmelCase ) for x_val in range(1 , order + 1 )] _UpperCAmelCase = [ interpolate(data_points[:max_coeff] ) for max_coeff in range(1 , order + 1 ) ] _UpperCAmelCase = 0 _UpperCAmelCase = 42 _UpperCAmelCase = 42 for poly in polynomials: _UpperCAmelCase = 1 while func(_UpperCAmelCase ) == poly(_UpperCAmelCase ): x_val += 1 ret += poly(_UpperCAmelCase ) return ret if __name__ == "__main__": print(f"""{solution() = }""")
339
0
from __future__ import annotations from collections import deque from collections.abc import Sequence from dataclasses import dataclass from typing import Any @dataclass class __A: snake_case_ = 42 snake_case_ = None snake_case_ = None def __lowerCAmelCase ( ) -> Node | None: __a = Node(1 ) __a = Node(2 ) __a = Node(3 ) __a = Node(4 ) __a = Node(5 ) return tree def __lowerCAmelCase ( a__ ) -> list[int]: return [root.data, *preorder(root.left ), *preorder(root.right )] if root else [] def __lowerCAmelCase ( a__ ) -> list[int]: return postorder(root.left ) + postorder(root.right ) + [root.data] if root else [] def __lowerCAmelCase ( a__ ) -> list[int]: return [*inorder(root.left ), root.data, *inorder(root.right )] if root else [] def __lowerCAmelCase ( a__ ) -> int: return (max(height(root.left ) , height(root.right ) ) + 1) if root else 0 def __lowerCAmelCase ( a__ ) -> Sequence[Node | None]: __a = [] if root is None: return output __a = deque([root] ) while process_queue: __a = process_queue.popleft() output.append(node.data ) if node.left: process_queue.append(node.left ) if node.right: process_queue.append(node.right ) return output def __lowerCAmelCase ( a__ , a__ ) -> Sequence[Node | None]: __a = [] def populate_output(a__ , a__ ) -> None: if not root: return if level == 1: output.append(root.data ) elif level > 1: populate_output(root.left , level - 1 ) populate_output(root.right , level - 1 ) populate_output(a__ , a__ ) return output def __lowerCAmelCase ( a__ , a__ ) -> Sequence[Node | None]: __a = [] def populate_output(a__ , a__ ) -> None: if root is None: return if level == 1: output.append(root.data ) elif level > 1: populate_output(root.right , level - 1 ) populate_output(root.left , level - 1 ) populate_output(a__ , a__ ) return output def __lowerCAmelCase ( a__ ) -> Sequence[Node | None] | list[Any]: if root is None: return [] __a = [] __a = 0 __a = height(a__ ) for h in range(1 , height_tree + 1 ): if not flag: output.append(get_nodes_from_left_to_right(a__ , a__ ) ) __a = 1 else: output.append(get_nodes_from_right_to_left(a__ , a__ ) ) __a = 0 return output def __lowerCAmelCase ( ) -> None: # Main function for testing. __a = make_tree() print(F"""In-order Traversal: {inorder(a__ )}""" ) print(F"""Pre-order Traversal: {preorder(a__ )}""" ) print(F"""Post-order Traversal: {postorder(a__ )}""" , '''\n''' ) print(F"""Height of Tree: {height(a__ )}""" , '''\n''' ) print('''Complete Level Order Traversal: ''' ) print(level_order(a__ ) , '''\n''' ) print('''Level-wise order Traversal: ''' ) for level in range(1 , height(a__ ) + 1 ): print(F"""Level {level}:""" , get_nodes_from_left_to_right(a__ , level=a__ ) ) print('''\nZigZag order Traversal: ''' ) print(zigzag(a__ ) ) if __name__ == "__main__": import doctest doctest.testmod() main()
6
from __future__ import annotations def A ( _UpperCAmelCase : list[int] ) -> bool: '''simple docstring''' return len(set(_UpperCAmelCase ) ) == len(_UpperCAmelCase ) if __name__ == "__main__": import doctest doctest.testmod()
339
0
import json import os import unittest from transformers import OpenAIGPTTokenizer, OpenAIGPTTokenizerFast from transformers.models.openai.tokenization_openai import VOCAB_FILES_NAMES from transformers.testing_utils import require_ftfy, require_spacy, require_tokenizers from ...test_tokenization_common import TokenizerTesterMixin @require_tokenizers class A ( _UpperCAmelCase , unittest.TestCase ): """simple docstring""" lowerCamelCase = OpenAIGPTTokenizer lowerCamelCase = OpenAIGPTTokenizerFast lowerCamelCase = True lowerCamelCase = False def snake_case__ ( self : List[Any] )-> str: '''simple docstring''' super().setUp() # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt A__ = [ 'l', 'o', 'w', 'e', 'r', 's', 't', 'i', 'd', 'n', 'w</w>', 'r</w>', 't</w>', 'lo', 'low', 'er</w>', 'low</w>', 'lowest</w>', 'newer</w>', 'wider</w>', '<unk>', ] A__ = dict(zip(lowercase_,range(len(lowercase_ ) ) ) ) A__ = ['#version: 0.2', 'l o', 'lo w', 'e r</w>', ''] 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' ) as fp: fp.write(json.dumps(lowercase_ ) ) with open(self.merges_file,'w' ) as fp: fp.write('\n'.join(lowercase_ ) ) def snake_case__ ( self : Optional[int],lowercase_ : int )-> Optional[int]: '''simple docstring''' return "lower newer", "lower newer" def snake_case__ ( self : List[str] )-> Union[str, Any]: '''simple docstring''' A__ = OpenAIGPTTokenizer(self.vocab_file,self.merges_file ) A__ = 'lower' A__ = ['low', 'er</w>'] A__ = tokenizer.tokenize(lowercase_ ) self.assertListEqual(lowercase_,lowercase_ ) A__ = tokens + ['<unk>'] A__ = [1_4, 1_5, 2_0] self.assertListEqual(tokenizer.convert_tokens_to_ids(lowercase_ ),lowercase_ ) def snake_case__ ( self : Optional[Any],lowercase_ : Optional[int]=1_5 )-> str: '''simple docstring''' for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})' ): A__ = self.rust_tokenizer_class.from_pretrained(lowercase_,**lowercase_ ) # Simple input A__ = 'This is a simple input' A__ = ['This is a simple input 1', 'This is a simple input 2'] A__ = ('This is a simple input', 'This is a pair') A__ = [ ('This is a simple input 1', 'This is a simple input 2'), ('This is a simple pair 1', 'This is a simple pair 2'), ] # Simple input tests self.assertRaises(lowercase_,tokenizer_r.encode,lowercase_,max_length=lowercase_,padding='max_length' ) # Simple input self.assertRaises(lowercase_,tokenizer_r.encode_plus,lowercase_,max_length=lowercase_,padding='max_length' ) # Simple input self.assertRaises( lowercase_,tokenizer_r.batch_encode_plus,lowercase_,max_length=lowercase_,padding='max_length',) # Pair input self.assertRaises(lowercase_,tokenizer_r.encode,lowercase_,max_length=lowercase_,padding='max_length' ) # Pair input self.assertRaises(lowercase_,tokenizer_r.encode_plus,lowercase_,max_length=lowercase_,padding='max_length' ) # Pair input self.assertRaises( lowercase_,tokenizer_r.batch_encode_plus,lowercase_,max_length=lowercase_,padding='max_length',) def snake_case__ ( self : List[str] )-> Optional[int]: '''simple docstring''' pass @require_ftfy @require_spacy @require_tokenizers class A ( _UpperCAmelCase ): """simple docstring""" pass
7
import os UpperCAmelCase__ = {"I": 1, "V": 5, "X": 10, "L": 50, "C": 100, "D": 500, "M": 1000} def A ( _UpperCAmelCase : str ) -> int: '''simple docstring''' _UpperCAmelCase = 0 _UpperCAmelCase = 0 while index < len(_UpperCAmelCase ) - 1: _UpperCAmelCase = SYMBOLS[numerals[index]] _UpperCAmelCase = SYMBOLS[numerals[index + 1]] if current_value < next_value: total_value -= current_value else: total_value += current_value index += 1 total_value += SYMBOLS[numerals[index]] return total_value def A ( _UpperCAmelCase : int ) -> str: '''simple docstring''' _UpperCAmelCase = '' _UpperCAmelCase = num // 1_000 numerals += m_count * "M" num %= 1_000 _UpperCAmelCase = num // 100 if c_count == 9: numerals += "CM" c_count -= 9 elif c_count == 4: numerals += "CD" c_count -= 4 if c_count >= 5: numerals += "D" c_count -= 5 numerals += c_count * "C" num %= 100 _UpperCAmelCase = num // 10 if x_count == 9: numerals += "XC" x_count -= 9 elif x_count == 4: numerals += "XL" x_count -= 4 if x_count >= 5: numerals += "L" x_count -= 5 numerals += x_count * "X" num %= 10 if num == 9: numerals += "IX" num -= 9 elif num == 4: numerals += "IV" num -= 4 if num >= 5: numerals += "V" num -= 5 numerals += num * "I" return numerals def A ( _UpperCAmelCase : str = "/p089_roman.txt" ) -> int: '''simple docstring''' _UpperCAmelCase = 0 with open(os.path.dirname(_UpperCAmelCase ) + roman_numerals_filename ) as filea: _UpperCAmelCase = filea.readlines() for line in lines: _UpperCAmelCase = line.strip() _UpperCAmelCase = parse_roman_numerals(_UpperCAmelCase ) _UpperCAmelCase = generate_roman_numerals(_UpperCAmelCase ) savings += len(_UpperCAmelCase ) - len(_UpperCAmelCase ) return savings if __name__ == "__main__": print(f"""{solution() = }""")
339
0
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available lowerCAmelCase_ = { '''configuration_swinv2''': ['''SWINV2_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''Swinv2Config'''], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowerCAmelCase_ = [ '''SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST''', '''Swinv2ForImageClassification''', '''Swinv2ForMaskedImageModeling''', '''Swinv2Model''', '''Swinv2PreTrainedModel''', ] if TYPE_CHECKING: from .configuration_swinva import SWINV2_PRETRAINED_CONFIG_ARCHIVE_MAP, SwinvaConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_swinva import ( SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST, SwinvaForImageClassification, SwinvaForMaskedImageModeling, SwinvaModel, SwinvaPreTrainedModel, ) else: import sys lowerCAmelCase_ = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
8
import requests from bsa import BeautifulSoup def A ( _UpperCAmelCase : str , _UpperCAmelCase : dict ) -> str: '''simple docstring''' _UpperCAmelCase = BeautifulSoup(requests.get(_UpperCAmelCase , params=_UpperCAmelCase ).content , 'html.parser' ) _UpperCAmelCase = soup.find('div' , attrs={'class': 'gs_ri'} ) _UpperCAmelCase = div.find('div' , attrs={'class': 'gs_fl'} ).find_all('a' ) return anchors[2].get_text() if __name__ == "__main__": UpperCAmelCase__ = { "title": ( "Precisely geometry controlled microsupercapacitors for ultrahigh areal " "capacitance, volumetric capacitance, and energy density" ), "journal": "Chem. Mater.", "volume": 30, "pages": "3979-3990", "year": 2018, "hl": "en", } print(get_citation("https://scholar.google.com/scholar_lookup", params=params))
339
0
import unittest from transformers import is_torch_available from transformers.testing_utils import require_torch, slow, torch_device from ...generation.test_utils import GenerationTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST, OpenAIGPTConfig, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification, OpenAIGPTLMHeadModel, OpenAIGPTModel, ) class _lowercase : '''simple docstring''' def __init__( self :Optional[int] , lowerCAmelCase__ :Optional[Any] , lowerCAmelCase__ :int=13 , lowerCAmelCase__ :List[str]=7 , lowerCAmelCase__ :Dict=True , lowerCAmelCase__ :List[str]=True , lowerCAmelCase__ :str=True , lowerCAmelCase__ :List[Any]=99 , lowerCAmelCase__ :List[str]=32 , lowerCAmelCase__ :Any=5 , lowerCAmelCase__ :List[str]=4 , lowerCAmelCase__ :int=37 , lowerCAmelCase__ :Optional[int]="gelu" , lowerCAmelCase__ :str=0.1 , lowerCAmelCase__ :str=0.1 , lowerCAmelCase__ :Optional[Any]=512 , lowerCAmelCase__ :Union[str, Any]=16 , lowerCAmelCase__ :Dict=2 , lowerCAmelCase__ :Tuple=0.02 , lowerCAmelCase__ :List[Any]=3 , lowerCAmelCase__ :Tuple=4 , lowerCAmelCase__ :int=None , ) -> int: __SCREAMING_SNAKE_CASE : Dict = parent __SCREAMING_SNAKE_CASE : Any = batch_size __SCREAMING_SNAKE_CASE : Union[str, Any] = seq_length __SCREAMING_SNAKE_CASE : Optional[Any] = is_training __SCREAMING_SNAKE_CASE : int = use_token_type_ids __SCREAMING_SNAKE_CASE : Any = use_labels __SCREAMING_SNAKE_CASE : Any = vocab_size __SCREAMING_SNAKE_CASE : List[Any] = hidden_size __SCREAMING_SNAKE_CASE : int = num_hidden_layers __SCREAMING_SNAKE_CASE : List[Any] = num_attention_heads __SCREAMING_SNAKE_CASE : str = intermediate_size __SCREAMING_SNAKE_CASE : Tuple = hidden_act __SCREAMING_SNAKE_CASE : Dict = hidden_dropout_prob __SCREAMING_SNAKE_CASE : int = attention_probs_dropout_prob __SCREAMING_SNAKE_CASE : Optional[Any] = max_position_embeddings __SCREAMING_SNAKE_CASE : List[Any] = type_vocab_size __SCREAMING_SNAKE_CASE : List[str] = type_sequence_label_size __SCREAMING_SNAKE_CASE : List[str] = initializer_range __SCREAMING_SNAKE_CASE : Tuple = num_labels __SCREAMING_SNAKE_CASE : Union[str, Any] = num_choices __SCREAMING_SNAKE_CASE : Union[str, Any] = scope __SCREAMING_SNAKE_CASE : Union[str, Any] = self.vocab_size - 1 def __magic_name__( self :Optional[Any] ) -> List[Any]: __SCREAMING_SNAKE_CASE : Optional[int] = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) __SCREAMING_SNAKE_CASE : Optional[Any] = None if self.use_token_type_ids: __SCREAMING_SNAKE_CASE : Union[str, Any] = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) __SCREAMING_SNAKE_CASE : Dict = None __SCREAMING_SNAKE_CASE : Optional[int] = None __SCREAMING_SNAKE_CASE : Union[str, Any] = None if self.use_labels: __SCREAMING_SNAKE_CASE : Optional[int] = ids_tensor([self.batch_size] , self.type_sequence_label_size ) __SCREAMING_SNAKE_CASE : Tuple = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) __SCREAMING_SNAKE_CASE : Optional[Any] = ids_tensor([self.batch_size] , self.num_choices ) __SCREAMING_SNAKE_CASE : Optional[int] = OpenAIGPTConfig( vocab_size=self.vocab_size , n_embd=self.hidden_size , n_layer=self.num_hidden_layers , n_head=self.num_attention_heads , n_positions=self.max_position_embeddings , pad_token_id=self.pad_token_id , ) __SCREAMING_SNAKE_CASE : Any = ids_tensor([self.num_hidden_layers, self.num_attention_heads] , 2 ) return ( config, input_ids, head_mask, token_type_ids, sequence_labels, token_labels, choice_labels, ) def __magic_name__( self :Tuple , lowerCAmelCase__ :List[Any] , lowerCAmelCase__ :List[str] , lowerCAmelCase__ :Dict , lowerCAmelCase__ :Any , *lowerCAmelCase__ :Union[str, Any] ) -> Any: __SCREAMING_SNAKE_CASE : Any = OpenAIGPTModel(config=lowerCAmelCase__ ) model.to(lowerCAmelCase__ ) model.eval() __SCREAMING_SNAKE_CASE : Dict = model(lowerCAmelCase__ , token_type_ids=lowerCAmelCase__ , head_mask=lowerCAmelCase__ ) __SCREAMING_SNAKE_CASE : Tuple = model(lowerCAmelCase__ , token_type_ids=lowerCAmelCase__ ) __SCREAMING_SNAKE_CASE : str = model(lowerCAmelCase__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def __magic_name__( self :Optional[Any] , lowerCAmelCase__ :Union[str, Any] , lowerCAmelCase__ :Union[str, Any] , lowerCAmelCase__ :Any , lowerCAmelCase__ :Dict , *lowerCAmelCase__ :List[Any] ) -> Dict: __SCREAMING_SNAKE_CASE : Optional[Any] = OpenAIGPTLMHeadModel(lowerCAmelCase__ ) model.to(lowerCAmelCase__ ) model.eval() __SCREAMING_SNAKE_CASE : Tuple = model(lowerCAmelCase__ , token_type_ids=lowerCAmelCase__ , labels=lowerCAmelCase__ ) self.parent.assertEqual(result.loss.shape , () ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def __magic_name__( self :Tuple , lowerCAmelCase__ :Dict , lowerCAmelCase__ :str , lowerCAmelCase__ :Optional[Any] , lowerCAmelCase__ :List[str] , *lowerCAmelCase__ :Optional[Any] ) -> Any: __SCREAMING_SNAKE_CASE : Any = OpenAIGPTDoubleHeadsModel(lowerCAmelCase__ ) model.to(lowerCAmelCase__ ) model.eval() __SCREAMING_SNAKE_CASE : Any = model(lowerCAmelCase__ , token_type_ids=lowerCAmelCase__ , labels=lowerCAmelCase__ ) self.parent.assertEqual(result.loss.shape , () ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def __magic_name__( self :Dict , lowerCAmelCase__ :List[Any] , lowerCAmelCase__ :Union[str, Any] , lowerCAmelCase__ :List[Any] , lowerCAmelCase__ :str , *lowerCAmelCase__ :Optional[int] ) -> Dict: __SCREAMING_SNAKE_CASE : Optional[Any] = self.num_labels __SCREAMING_SNAKE_CASE : List[Any] = OpenAIGPTForSequenceClassification(lowerCAmelCase__ ) model.to(lowerCAmelCase__ ) model.eval() __SCREAMING_SNAKE_CASE : List[str] = ids_tensor([self.batch_size] , self.type_sequence_label_size ) __SCREAMING_SNAKE_CASE : Optional[Any] = model(lowerCAmelCase__ , token_type_ids=lowerCAmelCase__ , labels=lowerCAmelCase__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def __magic_name__( self :Optional[Any] ) -> str: __SCREAMING_SNAKE_CASE : str = self.prepare_config_and_inputs() ( ( __SCREAMING_SNAKE_CASE ) , ( __SCREAMING_SNAKE_CASE ) , ( __SCREAMING_SNAKE_CASE ) , ( __SCREAMING_SNAKE_CASE ) , ( __SCREAMING_SNAKE_CASE ) , ( __SCREAMING_SNAKE_CASE ) , ( __SCREAMING_SNAKE_CASE ) , ) : List[str] = config_and_inputs __SCREAMING_SNAKE_CASE : List[str] = { '''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''head_mask''': head_mask, } return config, inputs_dict @require_torch class _lowercase ( A__ , A__ , A__ , unittest.TestCase ): '''simple docstring''' SCREAMING_SNAKE_CASE__ : int = ( (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification) if is_torch_available() else () ) SCREAMING_SNAKE_CASE__ : str = ( (OpenAIGPTLMHeadModel,) if is_torch_available() else () ) # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly SCREAMING_SNAKE_CASE__ : str = ( { '''feature-extraction''': OpenAIGPTModel, '''text-classification''': OpenAIGPTForSequenceClassification, '''text-generation''': OpenAIGPTLMHeadModel, '''zero-shot''': OpenAIGPTForSequenceClassification, } if is_torch_available() else {} ) def __magic_name__( self :Optional[int] , lowerCAmelCase__ :str , lowerCAmelCase__ :List[Any] , lowerCAmelCase__ :List[Any] , lowerCAmelCase__ :List[Any] , lowerCAmelCase__ :Union[str, Any] ) -> Tuple: if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests": # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers. # `OpenAIGPTConfig` was never used in pipeline tests, either because of a missing checkpoint or because a # tiny config could not be created. return True return False def __magic_name__( self :List[str] , lowerCAmelCase__ :Dict , lowerCAmelCase__ :int , lowerCAmelCase__ :int=False ) -> Dict: __SCREAMING_SNAKE_CASE : Tuple = super()._prepare_for_class(lowerCAmelCase__ , lowerCAmelCase__ , return_labels=lowerCAmelCase__ ) if return_labels: if model_class.__name__ == "OpenAIGPTDoubleHeadsModel": __SCREAMING_SNAKE_CASE : Any = torch.zeros( (self.model_tester.batch_size, self.model_tester.num_choices, self.model_tester.seq_length) , dtype=torch.long , device=lowerCAmelCase__ , ) __SCREAMING_SNAKE_CASE : Tuple = inputs_dict['''labels'''] __SCREAMING_SNAKE_CASE : Dict = inputs_dict['''labels'''] __SCREAMING_SNAKE_CASE : List[Any] = torch.zeros( (self.model_tester.batch_size, self.model_tester.num_choices) , dtype=torch.long , device=lowerCAmelCase__ , ) __SCREAMING_SNAKE_CASE : Optional[int] = torch.zeros( self.model_tester.batch_size , dtype=torch.long , device=lowerCAmelCase__ ) return inputs_dict def __magic_name__( self :Optional[int] ) -> Union[str, Any]: __SCREAMING_SNAKE_CASE : int = OpenAIGPTModelTester(self ) __SCREAMING_SNAKE_CASE : Optional[Any] = ConfigTester(self , config_class=lowerCAmelCase__ , n_embd=37 ) def __magic_name__( self :Any ) -> Optional[Any]: self.config_tester.run_common_tests() def __magic_name__( self :List[str] ) -> Union[str, Any]: __SCREAMING_SNAKE_CASE : Tuple = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_openai_gpt_model(*lowerCAmelCase__ ) def __magic_name__( self :int ) -> int: __SCREAMING_SNAKE_CASE : Tuple = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_lm_head_model(*lowerCAmelCase__ ) def __magic_name__( self :List[str] ) -> Dict: __SCREAMING_SNAKE_CASE : List[str] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_double_lm_head_model(*lowerCAmelCase__ ) def __magic_name__( self :List[str] ) -> str: __SCREAMING_SNAKE_CASE : List[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*lowerCAmelCase__ ) @slow def __magic_name__( self :Any ) -> List[Any]: for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: __SCREAMING_SNAKE_CASE : Dict = OpenAIGPTModel.from_pretrained(lowerCAmelCase__ ) self.assertIsNotNone(lowerCAmelCase__ ) @require_torch class _lowercase ( unittest.TestCase ): '''simple docstring''' @slow def __magic_name__( self :Union[str, Any] ) -> Optional[int]: __SCREAMING_SNAKE_CASE : List[str] = OpenAIGPTLMHeadModel.from_pretrained('''openai-gpt''' ) model.to(lowerCAmelCase__ ) __SCREAMING_SNAKE_CASE : Optional[int] = torch.tensor([[481, 4_735, 544]] , dtype=torch.long , device=lowerCAmelCase__ ) # the president is __SCREAMING_SNAKE_CASE : Dict = [ 481, 4_735, 544, 246, 963, 870, 762, 239, 244, 40_477, 244, 249, 719, 881, 487, 544, 240, 244, 603, 481, ] # the president is a very good man. " \n " i\'m sure he is, " said the __SCREAMING_SNAKE_CASE : Dict = model.generate(lowerCAmelCase__ , do_sample=lowerCAmelCase__ ) self.assertListEqual(output_ids[0].tolist() , lowerCAmelCase__ )
9
import unittest import numpy as np from transformers import RoFormerConfig, 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.roformer.modeling_flax_roformer import ( FlaxRoFormerForMaskedLM, FlaxRoFormerForMultipleChoice, FlaxRoFormerForQuestionAnswering, FlaxRoFormerForSequenceClassification, FlaxRoFormerForTokenClassification, FlaxRoFormerModel, ) class __lowerCAmelCase ( unittest.TestCase ): def __init__( self : Optional[Any] , A : Dict , A : Union[str, Any]=13 , A : Dict=7 , A : Dict=True , A : Tuple=True , A : Union[str, Any]=True , A : int=True , A : Optional[int]=99 , A : List[str]=32 , A : List[Any]=5 , A : int=4 , A : Any=37 , A : Optional[int]="gelu" , A : Optional[Any]=0.1 , A : Any=0.1 , A : Union[str, Any]=5_12 , A : int=16 , A : List[str]=2 , A : Union[str, Any]=0.0_2 , A : Union[str, Any]=4 , ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = seq_length _UpperCAmelCase = is_training _UpperCAmelCase = use_attention_mask _UpperCAmelCase = use_token_type_ids _UpperCAmelCase = use_labels _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = type_vocab_size _UpperCAmelCase = type_sequence_label_size _UpperCAmelCase = initializer_range _UpperCAmelCase = num_choices def _lowerCamelCase ( self : Optional[Any]) -> List[Any]: """simple docstring""" _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size) _UpperCAmelCase = None if self.use_attention_mask: _UpperCAmelCase = random_attention_mask([self.batch_size, self.seq_length]) _UpperCAmelCase = None if self.use_token_type_ids: _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size) _UpperCAmelCase = RoFormerConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , is_decoder=A , initializer_range=self.initializer_range , ) return config, input_ids, token_type_ids, attention_mask def _lowerCamelCase ( self : List[Any]) -> List[str]: """simple docstring""" _UpperCAmelCase = self.prepare_config_and_inputs() _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = config_and_inputs _UpperCAmelCase = {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': attention_mask} return config, inputs_dict @require_flax class __lowerCAmelCase ( A , unittest.TestCase ): UpperCamelCase = True UpperCamelCase = ( ( FlaxRoFormerModel, FlaxRoFormerForMaskedLM, FlaxRoFormerForSequenceClassification, FlaxRoFormerForTokenClassification, FlaxRoFormerForMultipleChoice, FlaxRoFormerForQuestionAnswering, ) if is_flax_available() else () ) def _lowerCamelCase ( self : Optional[int]) -> Any: """simple docstring""" _UpperCAmelCase = FlaxRoFormerModelTester(self) @slow def _lowerCamelCase ( self : List[Any]) -> Dict: """simple docstring""" for model_class_name in self.all_model_classes: _UpperCAmelCase = model_class_name.from_pretrained('junnyu/roformer_chinese_small' , from_pt=A) _UpperCAmelCase = model(np.ones((1, 1))) self.assertIsNotNone(A) @require_flax class __lowerCAmelCase ( unittest.TestCase ): @slow def _lowerCamelCase ( self : List[Any]) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = FlaxRoFormerForMaskedLM.from_pretrained('junnyu/roformer_chinese_base') _UpperCAmelCase = jnp.array([[0, 1, 2, 3, 4, 5]]) _UpperCAmelCase = model(A)[0] _UpperCAmelCase = 5_00_00 _UpperCAmelCase = (1, 6, vocab_size) self.assertEqual(output.shape , A) _UpperCAmelCase = jnp.array( [[[-0.1_2_0_5, -1.0_2_6_5, 0.2_9_2_2], [-1.5_1_3_4, 0.1_9_7_4, 0.1_5_1_9], [-5.0_1_3_5, -3.9_0_0_3, -0.8_4_0_4]]]) self.assertTrue(jnp.allclose(output[:, :3, :3] , A , atol=1E-4))
339
0
import unittest from transformers import is_flax_available from transformers.testing_utils import require_flax, require_sentencepiece, require_tokenizers, require_torch, slow if is_flax_available(): import optax from flax.training.common_utils import onehot from transformers import AutoTokenizer, FlaxMTaForConditionalGeneration from transformers.models.ta.modeling_flax_ta import shift_tokens_right @require_torch @require_sentencepiece @require_tokenizers @require_flax class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): '''simple docstring''' @slow def SCREAMING_SNAKE_CASE_ (self : Tuple) ->Optional[Any]: '''simple docstring''' lowerCamelCase__: Optional[int] =FlaxMTaForConditionalGeneration.from_pretrained("google/mt5-small") lowerCamelCase__: Optional[int] =AutoTokenizer.from_pretrained("google/mt5-small") lowerCamelCase__: List[Any] =tokenizer("Hello there" , return_tensors="np").input_ids lowerCamelCase__: Dict =tokenizer("Hi I am" , return_tensors="np").input_ids lowerCamelCase__: Tuple =shift_tokens_right(UpperCAmelCase_ , model.config.pad_token_id , model.config.decoder_start_token_id) lowerCamelCase__: Optional[Any] =model(UpperCAmelCase_ , decoder_input_ids=UpperCAmelCase_).logits lowerCamelCase__: Optional[Any] =optax.softmax_cross_entropy(UpperCAmelCase_ , onehot(UpperCAmelCase_ , logits.shape[-1])).mean() lowerCamelCase__: Dict =-(labels.shape[-1] * loss.item()) lowerCamelCase__: List[str] =-84.9127 self.assertTrue(abs(mtf_score - EXPECTED_SCORE) < 1E-4)
10
UpperCAmelCase__ = {} def A ( _UpperCAmelCase : int , _UpperCAmelCase : int , _UpperCAmelCase : int ) -> int: '''simple docstring''' # if we are absent twice, or late 3 consecutive days, # no further prize strings are possible if late == 3 or absent == 2: return 0 # if we have no days left, and have not failed any other rules, # we have a prize string if days == 0: return 1 # No easy solution, so now we need to do the recursive calculation # First, check if the combination is already in the cache, and # if yes, return the stored value from there since we already # know the number of possible prize strings from this point on _UpperCAmelCase = (days, absent, late) if key in cache: return cache[key] # now we calculate the three possible ways that can unfold from # this point on, depending on our attendance today # 1) if we are late (but not absent), the "absent" counter stays as # it is, but the "late" counter increases by one _UpperCAmelCase = _calculate(days - 1 , _UpperCAmelCase , late + 1 ) # 2) if we are absent, the "absent" counter increases by 1, and the # "late" counter resets to 0 _UpperCAmelCase = _calculate(days - 1 , absent + 1 , 0 ) # 3) if we are on time, this resets the "late" counter and keeps the # absent counter _UpperCAmelCase = _calculate(days - 1 , _UpperCAmelCase , 0 ) _UpperCAmelCase = state_late + state_absent + state_ontime _UpperCAmelCase = prizestrings return prizestrings def A ( _UpperCAmelCase : int = 30 ) -> int: '''simple docstring''' return _calculate(_UpperCAmelCase , absent=0 , late=0 ) if __name__ == "__main__": print(solution())
339
0
from typing import Dict, Optional import numpy as np import datasets lowerCAmelCase__ = '\nIoU is the area of overlap between the predicted segmentation and the ground truth divided by the area of union\nbetween the predicted segmentation and the ground truth. For binary (two classes) or multi-class segmentation,\nthe mean IoU of the image is calculated by taking the IoU of each class and averaging them.\n' lowerCAmelCase__ = '\nArgs:\n predictions (`List[ndarray]`):\n List of predicted segmentation maps, each of shape (height, width). Each segmentation map can be of a different size.\n references (`List[ndarray]`):\n List of ground truth segmentation maps, each of shape (height, width). Each segmentation map can be of a different size.\n num_labels (`int`):\n Number of classes (categories).\n ignore_index (`int`):\n Index that will be ignored during evaluation.\n nan_to_num (`int`, *optional*):\n If specified, NaN values will be replaced by the number defined by the user.\n label_map (`dict`, *optional*):\n If specified, dictionary mapping old label indices to new label indices.\n reduce_labels (`bool`, *optional*, defaults to `False`):\n Whether or not to reduce all label values of segmentation maps by 1. Usually used for datasets where 0 is used for background,\n and background itself is not included in all classes of a dataset (e.g. ADE20k). The background label will be replaced by 255.\n\nReturns:\n `Dict[str, float | ndarray]` comprising various elements:\n - *mean_iou* (`float`):\n Mean Intersection-over-Union (IoU averaged over all categories).\n - *mean_accuracy* (`float`):\n Mean accuracy (averaged over all categories).\n - *overall_accuracy* (`float`):\n Overall accuracy on all images.\n - *per_category_accuracy* (`ndarray` of shape `(num_labels,)`):\n Per category accuracy.\n - *per_category_iou* (`ndarray` of shape `(num_labels,)`):\n Per category IoU.\n\nExamples:\n\n >>> import numpy as np\n\n >>> mean_iou = datasets.load_metric("mean_iou")\n\n >>> # suppose one has 3 different segmentation maps predicted\n >>> predicted_1 = np.array([[1, 2], [3, 4], [5, 255]])\n >>> actual_1 = np.array([[0, 3], [5, 4], [6, 255]])\n\n >>> predicted_2 = np.array([[2, 7], [9, 2], [3, 6]])\n >>> actual_2 = np.array([[1, 7], [9, 2], [3, 6]])\n\n >>> predicted_3 = np.array([[2, 2, 3], [8, 2, 4], [3, 255, 2]])\n >>> actual_3 = np.array([[1, 2, 2], [8, 2, 1], [3, 255, 1]])\n\n >>> predicted = [predicted_1, predicted_2, predicted_3]\n >>> ground_truth = [actual_1, actual_2, actual_3]\n\n >>> results = mean_iou.compute(predictions=predicted, references=ground_truth, num_labels=10, ignore_index=255, reduce_labels=False)\n >>> print(results) # doctest: +NORMALIZE_WHITESPACE\n {\'mean_iou\': 0.47750000000000004, \'mean_accuracy\': 0.5916666666666666, \'overall_accuracy\': 0.5263157894736842, \'per_category_iou\': array([0. , 0. , 0.375, 0.4 , 0.5 , 0. , 0.5 , 1. , 1. , 1. ]), \'per_category_accuracy\': array([0. , 0. , 0.75 , 0.66666667, 1. , 0. , 0.5 , 1. , 1. , 1. ])}\n' lowerCAmelCase__ = '\\n@software{MMSegmentation_Contributors_OpenMMLab_Semantic_Segmentation_2020,\nauthor = {{MMSegmentation Contributors}},\nlicense = {Apache-2.0},\nmonth = {7},\ntitle = {{OpenMMLab Semantic Segmentation Toolbox and Benchmark}},\nurl = {https://github.com/open-mmlab/mmsegmentation},\nyear = {2020}\n}' def _UpperCAmelCase (UpperCamelCase__ : List[str] , UpperCamelCase__ : Any , UpperCamelCase__ : Optional[int] , UpperCamelCase__ : bool , UpperCamelCase__ : Optional[Dict[int, int]] = None , UpperCamelCase__ : bool = False , ): if label_map is not None: for old_id, new_id in label_map.items(): _A : Union[str, Any] = new_id # turn into Numpy arrays _A : str = np.array(UpperCamelCase__ ) _A : List[Any] = np.array(UpperCamelCase__ ) if reduce_labels: _A : str = 255 _A : Union[str, Any] = label - 1 _A : Optional[int] = 255 _A : List[Any] = label != ignore_index _A : Any = np.not_equal(UpperCamelCase__ , UpperCamelCase__ ) _A : str = pred_label[mask] _A : Any = np.array(UpperCamelCase__ )[mask] _A : Tuple = pred_label[pred_label == label] _A : int = np.histogram(UpperCamelCase__ , bins=UpperCamelCase__ , range=(0, num_labels - 1) )[0] _A : List[Any] = np.histogram(UpperCamelCase__ , bins=UpperCamelCase__ , range=(0, num_labels - 1) )[0] _A : Optional[int] = np.histogram(UpperCamelCase__ , bins=UpperCamelCase__ , range=(0, num_labels - 1) )[0] _A : Tuple = area_pred_label + area_label - area_intersect return area_intersect, area_union, area_pred_label, area_label def _UpperCAmelCase (UpperCamelCase__ : Tuple , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Any , UpperCamelCase__ : bool , UpperCamelCase__ : Optional[Dict[int, int]] = None , UpperCamelCase__ : bool = False , ): _A : List[Any] = np.zeros((num_labels,) , dtype=np.floataa ) _A : int = np.zeros((num_labels,) , dtype=np.floataa ) _A : Union[str, Any] = np.zeros((num_labels,) , dtype=np.floataa ) _A : int = np.zeros((num_labels,) , dtype=np.floataa ) for result, gt_seg_map in zip(UpperCamelCase__ , UpperCamelCase__ ): _A , _A , _A , _A : str = intersect_and_union( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) total_area_intersect += area_intersect total_area_union += area_union total_area_pred_label += area_pred_label total_area_label += area_label return total_area_intersect, total_area_union, total_area_pred_label, total_area_label def _UpperCAmelCase (UpperCamelCase__ : List[Any] , UpperCamelCase__ : List[str] , UpperCamelCase__ : List[Any] , UpperCamelCase__ : bool , UpperCamelCase__ : Optional[int] = None , UpperCamelCase__ : Optional[Dict[int, int]] = None , UpperCamelCase__ : bool = False , ): _A , _A , _A , _A : Optional[int] = total_intersect_and_union( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # compute metrics _A : List[str] = {} _A : Any = total_area_intersect.sum() / total_area_label.sum() _A : Union[str, Any] = total_area_intersect / total_area_union _A : Union[str, Any] = total_area_intersect / total_area_label _A : Union[str, Any] = np.nanmean(UpperCamelCase__ ) _A : List[Any] = np.nanmean(UpperCamelCase__ ) _A : List[str] = all_acc _A : Tuple = iou _A : Tuple = acc if nan_to_num is not None: _A : List[Any] = {metric: np.nan_to_num(UpperCamelCase__ , nan=UpperCamelCase__ ) for metric, metric_value in metrics.items()} return metrics @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION) class lowerCAmelCase__ ( datasets.Metric): '''simple docstring''' def _lowerCamelCase ( self) -> Dict: return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( # 1st Seq - height dim, 2nd - width dim { "predictions": datasets.Sequence(datasets.Sequence(datasets.Value("uint16"))), "references": datasets.Sequence(datasets.Sequence(datasets.Value("uint16"))), }) , reference_urls=[ "https://github.com/open-mmlab/mmsegmentation/blob/71c201b1813267d78764f306a297ca717827c4bf/mmseg/core/evaluation/metrics.py" ] , ) def _lowerCamelCase ( self , __lowerCamelCase , __lowerCamelCase , __lowerCamelCase , __lowerCamelCase , __lowerCamelCase = None , __lowerCamelCase = None , __lowerCamelCase = False , ) -> Optional[Any]: _A : int = mean_iou( results=__lowerCamelCase , gt_seg_maps=__lowerCamelCase , num_labels=__lowerCamelCase , ignore_index=__lowerCamelCase , nan_to_num=__lowerCamelCase , label_map=__lowerCamelCase , reduce_labels=__lowerCamelCase , ) return iou_result
11
import os import sys import unittest UpperCAmelCase__ = 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_dummies # noqa: E402 from check_dummies import create_dummy_files, create_dummy_object, find_backend, read_init # noqa: E402 # Align TRANSFORMERS_PATH in check_dummies with the current path UpperCAmelCase__ = os.path.join(git_repo_path, "src", "diffusers") class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Tuple) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = find_backend(' if not is_torch_available():') self.assertEqual(A , 'torch') # backend_with_underscore = find_backend(" if not is_tensorflow_text_available():") # self.assertEqual(backend_with_underscore, "tensorflow_text") _UpperCAmelCase = find_backend(' if not (is_torch_available() and is_transformers_available()):') self.assertEqual(A , 'torch_and_transformers') # double_backend_with_underscore = find_backend( # " if not (is_sentencepiece_available() and is_tensorflow_text_available()):" # ) # self.assertEqual(double_backend_with_underscore, "sentencepiece_and_tensorflow_text") _UpperCAmelCase = find_backend( ' if not (is_torch_available() and is_transformers_available() and is_onnx_available()):') self.assertEqual(A , 'torch_and_transformers_and_onnx') def _lowerCamelCase ( self : int) -> Dict: """simple docstring""" _UpperCAmelCase = read_init() # We don't assert on the exact list of keys to allow for smooth grow of backend-specific objects self.assertIn('torch' , A) self.assertIn('torch_and_transformers' , A) self.assertIn('flax_and_transformers' , A) self.assertIn('torch_and_transformers_and_onnx' , A) # Likewise, we can't assert on the exact content of a key self.assertIn('UNet2DModel' , objects['torch']) self.assertIn('FlaxUNet2DConditionModel' , objects['flax']) self.assertIn('StableDiffusionPipeline' , objects['torch_and_transformers']) self.assertIn('FlaxStableDiffusionPipeline' , objects['flax_and_transformers']) self.assertIn('LMSDiscreteScheduler' , objects['torch_and_scipy']) self.assertIn('OnnxStableDiffusionPipeline' , objects['torch_and_transformers_and_onnx']) def _lowerCamelCase ( self : Union[str, Any]) -> List[Any]: """simple docstring""" _UpperCAmelCase = create_dummy_object('CONSTANT' , '\'torch\'') self.assertEqual(A , '\nCONSTANT = None\n') _UpperCAmelCase = create_dummy_object('function' , '\'torch\'') self.assertEqual( A , '\ndef function(*args, **kwargs):\n requires_backends(function, \'torch\')\n') _UpperCAmelCase = '\nclass FakeClass(metaclass=DummyObject):\n _backends = \'torch\'\n\n def __init__(self, *args, **kwargs):\n requires_backends(self, \'torch\')\n\n @classmethod\n def from_config(cls, *args, **kwargs):\n requires_backends(cls, \'torch\')\n\n @classmethod\n def from_pretrained(cls, *args, **kwargs):\n requires_backends(cls, \'torch\')\n' _UpperCAmelCase = create_dummy_object('FakeClass' , '\'torch\'') self.assertEqual(A , A) def _lowerCamelCase ( self : Dict) -> int: """simple docstring""" _UpperCAmelCase = '# This file is autogenerated by the command `make fix-copies`, do not edit.\nfrom ..utils import DummyObject, requires_backends\n\n\nCONSTANT = None\n\n\ndef function(*args, **kwargs):\n requires_backends(function, ["torch"])\n\n\nclass FakeClass(metaclass=DummyObject):\n _backends = ["torch"]\n\n def __init__(self, *args, **kwargs):\n requires_backends(self, ["torch"])\n\n @classmethod\n def from_config(cls, *args, **kwargs):\n requires_backends(cls, ["torch"])\n\n @classmethod\n def from_pretrained(cls, *args, **kwargs):\n requires_backends(cls, ["torch"])\n' _UpperCAmelCase = create_dummy_files({'torch': ['CONSTANT', 'function', 'FakeClass']}) self.assertEqual(dummy_files['torch'] , A)
339
0
from ...utils import is_torch_available, is_transformers_available if is_transformers_available() and is_torch_available(): from .pipeline_vq_diffusion import LearnedClassifierFreeSamplingEmbeddings, VQDiffusionPipeline
12
import logging import os import random import sys from dataclasses import dataclass, field from typing import Optional import datasets import numpy as np import pandas as pd from datasets import load_dataset import transformers from transformers import ( AutoConfig, BartForSequenceClassification, DataCollatorWithPadding, EvalPrediction, HfArgumentParser, TapexTokenizer, Trainer, TrainingArguments, default_data_collator, set_seed, ) from transformers.trainer_utils import get_last_checkpoint from transformers.utils import check_min_version from transformers.utils.versions import require_version # Will error if the minimal version of Transformers is not installed. Remove at your own risks. check_min_version("4.17.0.dev0") require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/text-classification/requirements.txt") UpperCAmelCase__ = logging.getLogger(__name__) @dataclass class __lowerCAmelCase : UpperCamelCase = field( default='''tab_fact''' , metadata={'''help''': '''The name of the dataset to use (via the datasets library).'''} ) UpperCamelCase = field( default='''tab_fact''' , metadata={'''help''': '''The configuration name of the dataset to use (via the datasets library).'''} , ) UpperCamelCase = field( default=1_0_2_4 , metadata={ '''help''': ( '''The maximum total input sequence length after tokenization. Sequences longer ''' '''than this will be truncated, sequences shorter will be padded.''' ) } , ) UpperCamelCase = field( default=A , metadata={'''help''': '''Overwrite the cached preprocessed datasets or not.'''} ) UpperCamelCase = field( default=A , 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.''' ) } , ) UpperCamelCase = field( default=A , metadata={ '''help''': ( '''For debugging purposes or quicker training, truncate the number of training examples to this ''' '''value if set.''' ) } , ) UpperCamelCase = field( default=A , metadata={ '''help''': ( '''For debugging purposes or quicker training, truncate the number of evaluation examples to this ''' '''value if set.''' ) } , ) UpperCamelCase = field( default=A , metadata={ '''help''': ( '''For debugging purposes or quicker training, truncate the number of prediction examples to this ''' '''value if set.''' ) } , ) UpperCamelCase = field( default=A , metadata={'''help''': '''A csv or a json file containing the training data.'''} ) UpperCamelCase = field( default=A , metadata={'''help''': '''A csv or a json file containing the validation data.'''} ) UpperCamelCase = field(default=A , metadata={'''help''': '''A csv or a json file containing the test data.'''} ) def _lowerCamelCase ( self : str) -> List[Any]: """simple docstring""" if self.dataset_name is not None: pass elif self.train_file is None or self.validation_file is None: raise ValueError('Need either a GLUE task, a training/validation file or a dataset name.') else: _UpperCAmelCase = self.train_file.split('.')[-1] assert train_extension in ["csv", "json"], "`train_file` should be a csv or a json file." _UpperCAmelCase = self.validation_file.split('.')[-1] assert ( validation_extension == train_extension ), "`validation_file` should have the same extension (csv or json) as `train_file`." @dataclass class __lowerCAmelCase : UpperCamelCase = field( default=A , metadata={'''help''': '''Path to pretrained model or model identifier from huggingface.co/models'''} ) UpperCamelCase = field( default=A , metadata={'''help''': '''Pretrained config name or path if not the same as model_name'''} ) UpperCamelCase = field( default=A , metadata={'''help''': '''Pretrained tokenizer name or path if not the same as model_name'''} ) UpperCamelCase = field( default=A , metadata={'''help''': '''Where do you want to store the pretrained models downloaded from huggingface.co'''} , ) UpperCamelCase = field( default=A , metadata={'''help''': '''Whether to use one of the fast tokenizer (backed by the tokenizers library) or not.'''} , ) UpperCamelCase = field( default='''main''' , metadata={'''help''': '''The specific model version to use (can be a branch name, tag name or commit id).'''} , ) UpperCamelCase = field( default=A , metadata={ '''help''': ( '''Will use the token generated when running `huggingface-cli login` (necessary to use this script ''' '''with private models).''' ) } , ) def A ( ) -> Optional[int]: '''simple docstring''' # See all possible arguments in src/transformers/training_args.py # or by passing the --help flag to this script. # We now keep distinct sets of args, for a cleaner separation of concerns. _UpperCAmelCase = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments) ) if len(sys.argv ) == 2 and sys.argv[1].endswith('.json' ): # If we pass only one argument to the script and it's the path to a json file, # let's parse it to get our arguments. _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1] ) ) else: _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = parser.parse_args_into_dataclasses() # Setup logging logging.basicConfig( format='%(asctime)s - %(levelname)s - %(name)s - %(message)s' , datefmt='%m/%d/%Y %H:%M:%S' , handlers=[logging.StreamHandler(sys.stdout )] , ) _UpperCAmelCase = training_args.get_process_log_level() logger.setLevel(_UpperCAmelCase ) datasets.utils.logging.set_verbosity(_UpperCAmelCase ) transformers.utils.logging.set_verbosity(_UpperCAmelCase ) transformers.utils.logging.enable_default_handler() transformers.utils.logging.enable_explicit_format() # Log on each process the small summary: logger.warning( F"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}" + F"distributed training: {bool(training_args.local_rank != -1 )}, 16-bits training: {training_args.fpaa}" ) logger.info(F"Training/evaluation parameters {training_args}" ) # Detecting last checkpoint. _UpperCAmelCase = None if os.path.isdir(training_args.output_dir ) and training_args.do_train and not training_args.overwrite_output_dir: _UpperCAmelCase = get_last_checkpoint(training_args.output_dir ) if last_checkpoint is None and len(os.listdir(training_args.output_dir ) ) > 0: raise ValueError( F"Output directory ({training_args.output_dir}) already exists and is not empty. " 'Use --overwrite_output_dir to overcome.' ) elif last_checkpoint is not None and training_args.resume_from_checkpoint is None: logger.info( F"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change " 'the `--output_dir` or add `--overwrite_output_dir` to train from scratch.' ) # Set seed before initializing model. set_seed(training_args.seed ) # Get the datasets: you can either provide your own CSV/JSON training and evaluation files (see below) # or specify a GLUE benchmark task (the dataset will be downloaded automatically from the datasets Hub). # # For JSON files, this script will use the `question` column for the input question and `table` column for the corresponding table. # # If the CSVs/JSONs contain only one non-label column, the script does single sentence classification on this # single column. You can easily tweak this behavior (see below) # # In distributed training, the load_dataset function guarantee that only one local process can concurrently # download the dataset. if data_args.dataset_name is not None: # Downloading and loading a dataset from the hub. _UpperCAmelCase = load_dataset( data_args.dataset_name , data_args.dataset_config_name , cache_dir=model_args.cache_dir ) else: # Loading a dataset from your local files. # CSV/JSON training and evaluation files are needed. _UpperCAmelCase = {'train': data_args.train_file, 'validation': data_args.validation_file} # Get the test dataset: you can provide your own CSV/JSON test file (see below) # when you use `do_predict` without specifying a GLUE benchmark task. if training_args.do_predict: if data_args.test_file is not None: _UpperCAmelCase = data_args.train_file.split('.' )[-1] _UpperCAmelCase = data_args.test_file.split('.' )[-1] assert ( test_extension == train_extension ), "`test_file` should have the same extension (csv or json) as `train_file`." _UpperCAmelCase = data_args.test_file else: raise ValueError('Need either a GLUE task or a test file for `do_predict`.' ) for key in data_files.keys(): logger.info(F"load a local file for {key}: {data_files[key]}" ) if data_args.train_file.endswith('.csv' ): # Loading a dataset from local csv files _UpperCAmelCase = load_dataset('csv' , data_files=_UpperCAmelCase , cache_dir=model_args.cache_dir ) else: # Loading a dataset from local json files _UpperCAmelCase = load_dataset('json' , data_files=_UpperCAmelCase , cache_dir=model_args.cache_dir ) # See more about loading any type of standard or custom dataset at # https://huggingface.co/docs/datasets/loading_datasets.html. # Labels _UpperCAmelCase = raw_datasets['train'].features['label'].names _UpperCAmelCase = len(_UpperCAmelCase ) # Load pretrained model and tokenizer # # In distributed training, the .from_pretrained methods guarantee that only one local process can concurrently # download model & vocab. _UpperCAmelCase = AutoConfig.from_pretrained( model_args.config_name if model_args.config_name else model_args.model_name_or_path , num_labels=_UpperCAmelCase , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , ) # load tapex tokenizer _UpperCAmelCase = TapexTokenizer.from_pretrained( model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path , cache_dir=model_args.cache_dir , use_fast=model_args.use_fast_tokenizer , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , add_prefix_space=_UpperCAmelCase , ) _UpperCAmelCase = BartForSequenceClassification.from_pretrained( model_args.model_name_or_path , from_tf=bool('.ckpt' in model_args.model_name_or_path ) , config=_UpperCAmelCase , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , ) # Padding strategy if data_args.pad_to_max_length: _UpperCAmelCase = 'max_length' else: # We will pad later, dynamically at batch creation, to the max sequence length in each batch _UpperCAmelCase = False # Some models have set the order of the labels to use, so let's make sure we do use it. _UpperCAmelCase = {'Refused': 0, 'Entailed': 1} _UpperCAmelCase = {0: 'Refused', 1: 'Entailed'} if data_args.max_seq_length > tokenizer.model_max_length: logger.warning( F"The max_seq_length passed ({data_args.max_seq_length}) is larger than the maximum length for the" F"model ({tokenizer.model_max_length}). Using max_seq_length={tokenizer.model_max_length}." ) _UpperCAmelCase = min(data_args.max_seq_length , tokenizer.model_max_length ) def preprocess_tabfact_function(_UpperCAmelCase : Union[str, Any] ): # Tokenize the texts def _convert_table_text_to_pandas(_UpperCAmelCase : Dict ): _UpperCAmelCase = [_table_row.split('#' ) for _table_row in _table_text.strip('\n' ).split('\n' )] _UpperCAmelCase = pd.DataFrame.from_records(_table_content[1:] , columns=_table_content[0] ) return _table_pd _UpperCAmelCase = examples['statement'] _UpperCAmelCase = list(map(_convert_table_text_to_pandas , examples['table_text'] ) ) _UpperCAmelCase = tokenizer(_UpperCAmelCase , _UpperCAmelCase , padding=_UpperCAmelCase , max_length=_UpperCAmelCase , truncation=_UpperCAmelCase ) _UpperCAmelCase = examples['label'] return result with training_args.main_process_first(desc='dataset map pre-processing' ): _UpperCAmelCase = raw_datasets.map( _UpperCAmelCase , batched=_UpperCAmelCase , load_from_cache_file=not data_args.overwrite_cache , desc='Running tokenizer on dataset' , ) if training_args.do_train: if "train" not in raw_datasets: raise ValueError('--do_train requires a train dataset' ) _UpperCAmelCase = raw_datasets['train'] if data_args.max_train_samples is not None: _UpperCAmelCase = train_dataset.select(range(data_args.max_train_samples ) ) if training_args.do_eval: if "validation" not in raw_datasets and "validation_matched" not in raw_datasets: raise ValueError('--do_eval requires a validation dataset' ) _UpperCAmelCase = raw_datasets['validation'] if data_args.max_eval_samples is not None: _UpperCAmelCase = eval_dataset.select(range(data_args.max_eval_samples ) ) if training_args.do_predict or data_args.test_file is not None: if "test" not in raw_datasets and "test_matched" not in raw_datasets: raise ValueError('--do_predict requires a test dataset' ) _UpperCAmelCase = raw_datasets['test'] if data_args.max_predict_samples is not None: _UpperCAmelCase = predict_dataset.select(range(data_args.max_predict_samples ) ) # Log a few random samples from the training set: if training_args.do_train: for index in random.sample(range(len(_UpperCAmelCase ) ) , 3 ): logger.info(F"Sample {index} of the training set: {train_dataset[index]}." ) # You can define your custom compute_metrics function. It takes an `EvalPrediction` object (a namedtuple with a # predictions and label_ids field) and has to return a dictionary string to float. def compute_metrics(_UpperCAmelCase : EvalPrediction ): _UpperCAmelCase = p.predictions[0] if isinstance(p.predictions , _UpperCAmelCase ) else p.predictions _UpperCAmelCase = np.argmax(_UpperCAmelCase , axis=1 ) return {"accuracy": (preds == p.label_ids).astype(np.floataa ).mean().item()} # Data collator will default to DataCollatorWithPadding, so we change it if we already did the padding. if data_args.pad_to_max_length: _UpperCAmelCase = default_data_collator elif training_args.fpaa: _UpperCAmelCase = DataCollatorWithPadding(_UpperCAmelCase , pad_to_multiple_of=8 ) else: _UpperCAmelCase = None # Initialize our Trainer _UpperCAmelCase = Trainer( model=_UpperCAmelCase , args=_UpperCAmelCase , train_dataset=train_dataset if training_args.do_train else None , eval_dataset=eval_dataset if training_args.do_eval else None , compute_metrics=_UpperCAmelCase , tokenizer=_UpperCAmelCase , data_collator=_UpperCAmelCase , ) # Training if training_args.do_train: _UpperCAmelCase = None if training_args.resume_from_checkpoint is not None: _UpperCAmelCase = training_args.resume_from_checkpoint elif last_checkpoint is not None: _UpperCAmelCase = last_checkpoint _UpperCAmelCase = trainer.train(resume_from_checkpoint=_UpperCAmelCase ) _UpperCAmelCase = train_result.metrics _UpperCAmelCase = ( data_args.max_train_samples if data_args.max_train_samples is not None else len(_UpperCAmelCase ) ) _UpperCAmelCase = min(_UpperCAmelCase , len(_UpperCAmelCase ) ) trainer.save_model() # Saves the tokenizer too for easy upload trainer.log_metrics('train' , _UpperCAmelCase ) trainer.save_metrics('train' , _UpperCAmelCase ) trainer.save_state() # Evaluation if training_args.do_eval: logger.info('*** Evaluate ***' ) _UpperCAmelCase = trainer.evaluate(eval_dataset=_UpperCAmelCase ) _UpperCAmelCase = data_args.max_eval_samples if data_args.max_eval_samples is not None else len(_UpperCAmelCase ) _UpperCAmelCase = min(_UpperCAmelCase , len(_UpperCAmelCase ) ) trainer.log_metrics('eval' , _UpperCAmelCase ) trainer.save_metrics('eval' , _UpperCAmelCase ) if training_args.do_predict: logger.info('*** Predict ***' ) # Removing the `label` columns because it contains -1 and Trainer won't like that. _UpperCAmelCase = predict_dataset.remove_columns('label' ) _UpperCAmelCase = trainer.predict(_UpperCAmelCase , metric_key_prefix='predict' ).predictions _UpperCAmelCase = np.argmax(_UpperCAmelCase , axis=1 ) _UpperCAmelCase = os.path.join(training_args.output_dir , 'predict_results_tabfact.txt' ) if trainer.is_world_process_zero(): with open(_UpperCAmelCase , 'w' ) as writer: logger.info('***** Predict Results *****' ) writer.write('index\tprediction\n' ) for index, item in enumerate(_UpperCAmelCase ): _UpperCAmelCase = label_list[item] writer.write(F"{index}\t{item}\n" ) _UpperCAmelCase = {'finetuned_from': model_args.model_name_or_path, 'tasks': 'text-classification'} if training_args.push_to_hub: trainer.push_to_hub(**_UpperCAmelCase ) else: trainer.create_model_card(**_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[Any] ) -> Optional[Any]: '''simple docstring''' # For xla_spawn (TPUs) main() if __name__ == "__main__": main()
339
0
from __future__ import annotations lowerCAmelCase : List[Any] = """Muhammad Umer Farooq""" lowerCAmelCase : Tuple = """MIT""" lowerCAmelCase : List[str] = """1.0.0""" lowerCAmelCase : Any = """Muhammad Umer Farooq""" lowerCAmelCase : Optional[Any] = """[email protected]""" lowerCAmelCase : Optional[Any] = """Alpha""" import re from html.parser import HTMLParser from urllib import parse import requests class __lowercase ( UpperCAmelCase_ ): """simple docstring""" def __init__( self : Dict , lowerCAmelCase__ : str): super().__init__() SCREAMING_SNAKE_CASE_: list[str] = [] SCREAMING_SNAKE_CASE_: List[Any] = domain def _SCREAMING_SNAKE_CASE ( self : Optional[Any] , lowerCAmelCase__ : str , lowerCAmelCase__ : list[tuple[str, str | None]]): # Only parse the 'anchor' tag. if tag == "a": # Check the list of defined attributes. for name, value in attrs: # If href is defined, and not empty nor # print it. if name == "href" and value != "#" and value != "": # If not already in urls. if value not in self.urls: SCREAMING_SNAKE_CASE_: str = parse.urljoin(self.domain , lowerCAmelCase__) self.urls.append(lowerCAmelCase__) def A_ ( _UpperCAmelCase ): return ".".join(get_sub_domain_name(_UpperCAmelCase ).split("." )[-2:] ) def A_ ( _UpperCAmelCase ): return parse.urlparse(_UpperCAmelCase ).netloc def A_ ( _UpperCAmelCase = "https://github.com" ): SCREAMING_SNAKE_CASE_: Optional[int] = get_domain_name(_UpperCAmelCase ) # Initialize the parser SCREAMING_SNAKE_CASE_: Any = Parser(_UpperCAmelCase ) try: # Open URL SCREAMING_SNAKE_CASE_: Any = requests.get(_UpperCAmelCase ) # pass the raw HTML to the parser to get links parser.feed(r.text ) # Get links and loop through SCREAMING_SNAKE_CASE_: Dict = set() for link in parser.urls: # open URL. # read = requests.get(link) try: SCREAMING_SNAKE_CASE_: Optional[Any] = requests.get(_UpperCAmelCase ) # Get the valid email. SCREAMING_SNAKE_CASE_: Dict = re.findall("[a-zA-Z0-9]+@" + domain , read.text ) # If not in list then append it. for email in emails: valid_emails.add(_UpperCAmelCase ) except ValueError: pass except ValueError: raise SystemExit(1 ) # Finally return a sorted list of email addresses with no duplicates. return sorted(_UpperCAmelCase ) if __name__ == "__main__": lowerCAmelCase : List[Any] = emails_from_url("""https://github.com""") print(f'''{len(emails)} emails found:''') print("""\n""".join(sorted(emails)))
13
# This code is adapted from OpenAI's release # https://github.com/openai/human-eval/blob/master/human_eval/execution.py import contextlib import faulthandler import io import multiprocessing import os import platform import signal import tempfile def A ( _UpperCAmelCase : Union[str, Any] , _UpperCAmelCase : Dict , _UpperCAmelCase : Dict , _UpperCAmelCase : Dict ) -> Any: '''simple docstring''' _UpperCAmelCase = multiprocessing.Manager() _UpperCAmelCase = manager.list() _UpperCAmelCase = multiprocessing.Process(target=_UpperCAmelCase , args=(check_program, result, timeout) ) p.start() p.join(timeout=timeout + 1 ) if p.is_alive(): p.kill() if not result: result.append('timed out' ) return { "task_id": task_id, "passed": result[0] == "passed", "result": result[0], "completion_id": completion_id, } def A ( _UpperCAmelCase : str , _UpperCAmelCase : List[str] , _UpperCAmelCase : Dict ) -> Optional[int]: '''simple docstring''' with create_tempdir(): # These system calls are needed when cleaning up tempdir. import os import shutil _UpperCAmelCase = shutil.rmtree _UpperCAmelCase = os.rmdir _UpperCAmelCase = os.chdir # Disable functionalities that can make destructive changes to the test. reliability_guard() # Run program. try: _UpperCAmelCase = {} with swallow_io(): with time_limit(_UpperCAmelCase ): exec(_UpperCAmelCase , _UpperCAmelCase ) result.append('passed' ) except TimeoutException: result.append('timed out' ) except BaseException as e: result.append(F"failed: {e}" ) # Needed for cleaning up. _UpperCAmelCase = rmtree _UpperCAmelCase = rmdir _UpperCAmelCase = chdir @contextlib.contextmanager def A ( _UpperCAmelCase : Union[str, Any] ) -> Any: '''simple docstring''' def signal_handler(_UpperCAmelCase : List[Any] , _UpperCAmelCase : Dict ): raise TimeoutException('Timed out!' ) signal.setitimer(signal.ITIMER_REAL , _UpperCAmelCase ) signal.signal(signal.SIGALRM , _UpperCAmelCase ) try: yield finally: signal.setitimer(signal.ITIMER_REAL , 0 ) @contextlib.contextmanager def A ( ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = WriteOnlyStringIO() with contextlib.redirect_stdout(_UpperCAmelCase ): with contextlib.redirect_stderr(_UpperCAmelCase ): with redirect_stdin(_UpperCAmelCase ): yield @contextlib.contextmanager def A ( ) -> Any: '''simple docstring''' with tempfile.TemporaryDirectory() as dirname: with chdir(_UpperCAmelCase ): yield dirname class __lowerCAmelCase ( A ): pass class __lowerCAmelCase ( io.StringIO ): def _lowerCamelCase ( self : Tuple , *A : str , **A : Any) -> Any: """simple docstring""" raise OSError def _lowerCamelCase ( self : List[str] , *A : Optional[Any] , **A : Optional[Any]) -> Optional[int]: """simple docstring""" raise OSError def _lowerCamelCase ( self : str , *A : List[str] , **A : List[Any]) -> Union[str, Any]: """simple docstring""" raise OSError def _lowerCamelCase ( self : Union[str, Any] , *A : Optional[Any] , **A : List[str]) -> Optional[int]: """simple docstring""" return False class __lowerCAmelCase ( contextlib._RedirectStream ): # type: ignore UpperCamelCase = '''stdin''' @contextlib.contextmanager def A ( _UpperCAmelCase : List[Any] ) -> Dict: '''simple docstring''' if root == ".": yield return _UpperCAmelCase = os.getcwd() os.chdir(_UpperCAmelCase ) try: yield except BaseException as exc: raise exc finally: os.chdir(_UpperCAmelCase ) def A ( _UpperCAmelCase : List[str]=None ) -> Any: '''simple docstring''' if maximum_memory_bytes is not None: import resource resource.setrlimit(resource.RLIMIT_AS , (maximum_memory_bytes, maximum_memory_bytes) ) resource.setrlimit(resource.RLIMIT_DATA , (maximum_memory_bytes, maximum_memory_bytes) ) if not platform.uname().system == "Darwin": resource.setrlimit(resource.RLIMIT_STACK , (maximum_memory_bytes, maximum_memory_bytes) ) faulthandler.disable() import builtins _UpperCAmelCase = None _UpperCAmelCase = None import os _UpperCAmelCase = '1' _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None import shutil _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None import subprocess _UpperCAmelCase = None # type: ignore _UpperCAmelCase = None import sys _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None
339
0
import argparse from typing import List import evaluate import numpy as np import torch from datasets import DatasetDict, load_dataset # New Code # # We'll be using StratifiedKFold for this example from sklearn.model_selection import StratifiedKFold 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 ######################################################################## # This is a fully working simple example to use Accelerate, # specifically showcasing how to perform Cross Validation, # 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) # # To help focus on the differences in the code, building `DataLoaders` # was refactored into its own function. # 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 # ######################################################################## _lowerCamelCase : List[str] = 16 _lowerCamelCase : int = 32 def SCREAMING_SNAKE_CASE ( lowercase_ , lowercase_ , lowercase_ , lowercase_ , lowercase_ = 16 ) -> List[str]: """simple docstring""" A__ = AutoTokenizer.from_pretrained('''bert-base-cased''' ) A__ = DatasetDict( { '''train''': dataset['''train'''].select(lowercase_ ), '''validation''': dataset['''train'''].select(lowercase_ ), '''test''': dataset['''validation'''], } ) def tokenize_function(lowercase_ ): # max_length=None => use the model max length (it's actually the default) A__ = tokenizer(examples['''sentence1'''] , examples['''sentence2'''] , truncation=lowercase_ , max_length=lowercase_ ) 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( lowercase_ , batched=lowercase_ , 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(lowercase_ ): # On TPU it's best to pad everything to the same length or training will be very slow. A__ = 128 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__ = 16 elif accelerator.mixed_precision != "no": A__ = 8 else: A__ = None return tokenizer.pad( lowercase_ , padding='''longest''' , max_length=lowercase_ , pad_to_multiple_of=lowercase_ , return_tensors='''pt''' , ) # Instantiate dataloaders. A__ = DataLoader( tokenized_datasets['''train'''] , shuffle=lowercase_ , collate_fn=lowercase_ , batch_size=lowercase_ ) A__ = DataLoader( tokenized_datasets['''validation'''] , shuffle=lowercase_ , collate_fn=lowercase_ , batch_size=lowercase_ ) A__ = DataLoader( tokenized_datasets['''test'''] , shuffle=lowercase_ , collate_fn=lowercase_ , batch_size=lowercase_ ) return train_dataloader, eval_dataloader, test_dataloader def SCREAMING_SNAKE_CASE ( lowercase_ , lowercase_ ) -> Union[str, Any]: """simple docstring""" A__ = [] # Download the dataset A__ = load_dataset('''glue''' , '''mrpc''' ) # Create our splits A__ = StratifiedKFold(n_splits=int(args.num_folds ) ) # 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''' ) # If the batch size is too big we use gradient accumulation A__ = 1 if batch_size > MAX_GPU_BATCH_SIZE and accelerator.distributed_type != DistributedType.TPU: A__ = batch_size // MAX_GPU_BATCH_SIZE A__ = MAX_GPU_BATCH_SIZE set_seed(lowercase_ ) # New Code # # Create our folds: A__ = kfold.split(np.zeros(datasets['''train'''].num_rows ) , datasets['''train''']['''label'''] ) A__ = [] # Iterate over them for i, (train_idxs, valid_idxs) in enumerate(lowercase_ ): A__ , A__ , A__ = get_fold_dataloaders( lowercase_ , lowercase_ , lowercase_ , lowercase_ , ) # 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=lowercase_ ) # 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=lowercase_ ) # Instantiate scheduler A__ = get_linear_schedule_with_warmup( optimizer=lowercase_ , num_warmup_steps=100 , num_training_steps=(len(lowercase_ ) * num_epochs) // gradient_accumulation_steps , ) # 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( lowercase_ , lowercase_ , lowercase_ , lowercase_ , lowercase_ ) # Now we train the model for epoch in range(lowercase_ ): model.train() for step, batch in enumerate(lowercase_ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) A__ = model(**lowercase_ ) A__ = outputs.loss A__ = loss / gradient_accumulation_steps accelerator.backward(lowercase_ ) if step % gradient_accumulation_steps == 0: optimizer.step() lr_scheduler.step() optimizer.zero_grad() model.eval() for step, batch in enumerate(lowercase_ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) with torch.no_grad(): A__ = model(**lowercase_ ) A__ = outputs.logits.argmax(dim=-1 ) A__ , A__ = accelerator.gather_for_metrics((predictions, batch['''labels''']) ) metric.add_batch( predictions=lowercase_ , references=lowercase_ , ) A__ = metric.compute() # Use accelerator.print to print only on the main process. accelerator.print(f"""epoch {epoch}:""" , lowercase_ ) # New Code # # We also run predictions on the test set at the very end A__ = [] for step, batch in enumerate(lowercase_ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) with torch.no_grad(): A__ = model(**lowercase_ ) A__ = outputs.logits A__ , A__ = accelerator.gather_for_metrics((predictions, batch['''labels''']) ) fold_predictions.append(predictions.cpu() ) if i == 0: # We need all of the test predictions test_references.append(references.cpu() ) # Use accelerator.print to print only on the main process. test_predictions.append(torch.cat(lowercase_ , dim=0 ) ) # We now need to release all our memory and get rid of the current model, optimizer, etc accelerator.free_memory() # New Code # # Finally we check the accuracy of our folded results: A__ = torch.cat(lowercase_ , dim=0 ) A__ = torch.stack(lowercase_ , dim=0 ).sum(dim=0 ).div(int(args.num_folds ) ).argmax(dim=-1 ) A__ = metric.compute(predictions=lowercase_ , references=lowercase_ ) accelerator.print('''Average test metrics from all folds:''' , lowercase_ ) def SCREAMING_SNAKE_CASE ( ) -> Tuple: """simple docstring""" A__ = argparse.ArgumentParser(description='''Simple example of training script.''' ) parser.add_argument( '''--mixed_precision''' , type=lowercase_ , default=lowercase_ , 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.''' ) # New Code # parser.add_argument('''--num_folds''' , type=lowercase_ , default=3 , help='''The number of splits to perform across the dataset''' ) A__ = parser.parse_args() A__ = {'''lr''': 2E-5, '''num_epochs''': 3, '''seed''': 42, '''batch_size''': 16} training_function(lowercase_ , lowercase_ ) if __name__ == "__main__": main()
14
import asyncio import os import shutil import subprocess import sys import tempfile import unittest from distutils.util import strtobool from functools import partial from pathlib import Path from typing import List, Union from unittest import mock import torch from ..state import AcceleratorState, PartialState from ..utils import ( gather, is_bnb_available, is_comet_ml_available, is_datasets_available, is_deepspeed_available, is_mps_available, is_safetensors_available, is_tensorboard_available, is_torch_version, is_tpu_available, is_transformers_available, is_wandb_available, is_xpu_available, ) def A ( _UpperCAmelCase : Tuple , _UpperCAmelCase : Union[str, Any]=False ) -> str: '''simple docstring''' try: _UpperCAmelCase = os.environ[key] except KeyError: # KEY isn't set, default to `default`. _UpperCAmelCase = default else: # KEY is set, convert it to True or False. try: _UpperCAmelCase = strtobool(_UpperCAmelCase ) except ValueError: # More values are supported, but let's keep the message simple. raise ValueError(F"If set, {key} must be yes or no." ) return _value UpperCAmelCase__ = parse_flag_from_env("RUN_SLOW", default=False) def A ( _UpperCAmelCase : List[str] ) -> List[str]: '''simple docstring''' return unittest.skip('Test was skipped' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Dict ) -> str: '''simple docstring''' return unittest.skipUnless(_run_slow_tests , 'test is slow' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Any ) -> str: '''simple docstring''' return unittest.skipUnless(not torch.cuda.is_available() , 'test requires only a CPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Dict ) -> Dict: '''simple docstring''' return unittest.skipUnless(torch.cuda.is_available() , 'test requires a GPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[Any] ) -> List[Any]: '''simple docstring''' return unittest.skipUnless(is_xpu_available() , 'test requires a XPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[int] ) -> List[str]: '''simple docstring''' return unittest.skipUnless(is_mps_available() , 'test requires a `mps` backend support in `torch`' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Union[str, Any] ) -> List[Any]: '''simple docstring''' return unittest.skipUnless( is_transformers_available() and is_datasets_available() , 'test requires the Hugging Face suite' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : str ) -> str: '''simple docstring''' return unittest.skipUnless(is_bnb_available() , 'test requires the bitsandbytes library' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Union[str, Any] ) -> List[Any]: '''simple docstring''' return unittest.skipUnless(is_tpu_available() , 'test requires TPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[Any] ) -> str: '''simple docstring''' return unittest.skipUnless(torch.cuda.device_count() == 1 , 'test requires a GPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Tuple ) -> int: '''simple docstring''' return unittest.skipUnless(torch.xpu.device_count() == 1 , 'test requires a XPU' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Any ) -> Optional[int]: '''simple docstring''' return unittest.skipUnless(torch.cuda.device_count() > 1 , 'test requires multiple GPUs' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Tuple ) -> Any: '''simple docstring''' return unittest.skipUnless(torch.xpu.device_count() > 1 , 'test requires multiple XPUs' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Any ) -> Optional[int]: '''simple docstring''' return unittest.skipUnless(is_safetensors_available() , 'test requires safetensors' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : List[Any] ) -> Dict: '''simple docstring''' return unittest.skipUnless(is_deepspeed_available() , 'test requires DeepSpeed' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Optional[int] ) -> str: '''simple docstring''' return unittest.skipUnless(is_torch_version('>=' , '1.12.0' ) , 'test requires torch version >= 1.12.0' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Any=None , _UpperCAmelCase : List[Any]=None ) -> Dict: '''simple docstring''' if test_case is None: return partial(_UpperCAmelCase , version=_UpperCAmelCase ) return unittest.skipUnless(is_torch_version('>=' , _UpperCAmelCase ) , F"test requires torch version >= {version}" )(_UpperCAmelCase ) def A ( _UpperCAmelCase : List[str] ) -> int: '''simple docstring''' return unittest.skipUnless(is_tensorboard_available() , 'test requires Tensorboard' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : Union[str, Any] ) -> Union[str, Any]: '''simple docstring''' return unittest.skipUnless(is_wandb_available() , 'test requires wandb' )(_UpperCAmelCase ) def A ( _UpperCAmelCase : List[str] ) -> Optional[int]: '''simple docstring''' return unittest.skipUnless(is_comet_ml_available() , 'test requires comet_ml' )(_UpperCAmelCase ) UpperCAmelCase__ = ( any([is_wandb_available(), is_tensorboard_available()]) and not is_comet_ml_available() ) def A ( _UpperCAmelCase : List[str] ) -> Any: '''simple docstring''' return unittest.skipUnless( _atleast_one_tracker_available , 'test requires at least one tracker to be available and for `comet_ml` to not be installed' , )(_UpperCAmelCase ) class __lowerCAmelCase ( unittest.TestCase ): UpperCamelCase = True @classmethod def _lowerCamelCase ( cls : List[Any]) -> Tuple: """simple docstring""" _UpperCAmelCase = tempfile.mkdtemp() @classmethod def _lowerCamelCase ( cls : Union[str, Any]) -> str: """simple docstring""" if os.path.exists(cls.tmpdir): shutil.rmtree(cls.tmpdir) def _lowerCamelCase ( self : List[str]) -> List[Any]: """simple docstring""" if self.clear_on_setup: for path in Path(self.tmpdir).glob('**/*'): if path.is_file(): path.unlink() elif path.is_dir(): shutil.rmtree(A) class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Dict) -> Tuple: """simple docstring""" super().tearDown() # Reset the state of the AcceleratorState singleton. AcceleratorState._reset_state() PartialState._reset_state() class __lowerCAmelCase ( unittest.TestCase ): def _lowerCamelCase ( self : Optional[int] , A : Union[mock.Mock, List[mock.Mock]]) -> Tuple: """simple docstring""" _UpperCAmelCase = mocks if isinstance(A , (tuple, list)) else [mocks] for m in self.mocks: m.start() self.addCleanup(m.stop) def A ( _UpperCAmelCase : List[Any] ) -> int: '''simple docstring''' _UpperCAmelCase = AcceleratorState() _UpperCAmelCase = tensor[None].clone().to(state.device ) _UpperCAmelCase = gather(_UpperCAmelCase ).cpu() _UpperCAmelCase = tensor[0].cpu() for i in range(tensors.shape[0] ): if not torch.equal(tensors[i] , _UpperCAmelCase ): return False return True class __lowerCAmelCase : def __init__( self : Optional[Any] , A : Union[str, Any] , A : Optional[int] , A : str) -> Optional[int]: """simple docstring""" _UpperCAmelCase = returncode _UpperCAmelCase = stdout _UpperCAmelCase = stderr async def A ( _UpperCAmelCase : str , _UpperCAmelCase : Optional[int] ) -> Optional[Any]: '''simple docstring''' while True: _UpperCAmelCase = await stream.readline() if line: callback(_UpperCAmelCase ) else: break async def A ( _UpperCAmelCase : Optional[int] , _UpperCAmelCase : List[str]=None , _UpperCAmelCase : str=None , _UpperCAmelCase : str=None , _UpperCAmelCase : Dict=False , _UpperCAmelCase : Union[str, Any]=False ) -> _RunOutput: '''simple docstring''' if echo: print('\nRunning: ' , ' '.join(_UpperCAmelCase ) ) _UpperCAmelCase = await asyncio.create_subprocess_exec( cmd[0] , *cmd[1:] , stdin=_UpperCAmelCase , stdout=asyncio.subprocess.PIPE , stderr=asyncio.subprocess.PIPE , env=_UpperCAmelCase , ) # note: there is a warning for a possible deadlock when using `wait` with huge amounts of data in the pipe # https://docs.python.org/3/library/asyncio-subprocess.html#asyncio.asyncio.subprocess.Process.wait # # If it starts hanging, will need to switch to the following code. The problem is that no data # will be seen until it's done and if it hangs for example there will be no debug info. # out, err = await p.communicate() # return _RunOutput(p.returncode, out, err) _UpperCAmelCase = [] _UpperCAmelCase = [] def tee(_UpperCAmelCase : Union[str, Any] , _UpperCAmelCase : List[Any] , _UpperCAmelCase : str , _UpperCAmelCase : str="" ): _UpperCAmelCase = line.decode('utf-8' ).rstrip() sink.append(_UpperCAmelCase ) if not quiet: print(_UpperCAmelCase , _UpperCAmelCase , file=_UpperCAmelCase ) # XXX: the timeout doesn't seem to make any difference here await asyncio.wait( [ asyncio.create_task(_read_stream(p.stdout , lambda _UpperCAmelCase : tee(_UpperCAmelCase , _UpperCAmelCase , sys.stdout , label='stdout:' ) ) ), asyncio.create_task(_read_stream(p.stderr , lambda _UpperCAmelCase : tee(_UpperCAmelCase , _UpperCAmelCase , sys.stderr , label='stderr:' ) ) ), ] , timeout=_UpperCAmelCase , ) return _RunOutput(await p.wait() , _UpperCAmelCase , _UpperCAmelCase ) def A ( _UpperCAmelCase : str , _UpperCAmelCase : Dict=None , _UpperCAmelCase : str=None , _UpperCAmelCase : str=180 , _UpperCAmelCase : List[Any]=False , _UpperCAmelCase : List[Any]=True ) -> _RunOutput: '''simple docstring''' _UpperCAmelCase = asyncio.get_event_loop() _UpperCAmelCase = loop.run_until_complete( _stream_subprocess(_UpperCAmelCase , env=_UpperCAmelCase , stdin=_UpperCAmelCase , timeout=_UpperCAmelCase , quiet=_UpperCAmelCase , echo=_UpperCAmelCase ) ) _UpperCAmelCase = ' '.join(_UpperCAmelCase ) if result.returncode > 0: _UpperCAmelCase = '\n'.join(result.stderr ) raise RuntimeError( F"'{cmd_str}' failed with returncode {result.returncode}\n\n" F"The combined stderr from workers follows:\n{stderr}" ) return result class __lowerCAmelCase ( A ): pass def A ( _UpperCAmelCase : List[str] , _UpperCAmelCase : str=False ) -> Tuple: '''simple docstring''' try: _UpperCAmelCase = subprocess.check_output(_UpperCAmelCase , stderr=subprocess.STDOUT ) if return_stdout: if hasattr(_UpperCAmelCase , 'decode' ): _UpperCAmelCase = output.decode('utf-8' ) return output except subprocess.CalledProcessError as e: raise SubprocessCallException( F"Command `{' '.join(_UpperCAmelCase )}` failed with the following error:\n\n{e.output.decode()}" ) from e
339
0
import math import unittest from transformers import BioGptConfig, is_torch_available from transformers.testing_utils import require_torch, slow, torch_device from ...generation.test_utils import GenerationTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( BioGptForCausalLM, BioGptForSequenceClassification, BioGptForTokenClassification, BioGptModel, BioGptTokenizer, ) from transformers.models.biogpt.modeling_biogpt import BIOGPT_PRETRAINED_MODEL_ARCHIVE_LIST class UpperCAmelCase : '''simple docstring''' def __init__( self : Optional[int] ,A : Tuple ,A : str=13 ,A : List[str]=7 ,A : Dict=True ,A : Optional[Any]=True ,A : Union[str, Any]=False ,A : Optional[int]=True ,A : int=99 ,A : Any=32 ,A : int=5 ,A : Tuple=4 ,A : Optional[Any]=37 ,A : Dict="gelu" ,A : int=0.1 ,A : Optional[Any]=0.1 ,A : int=5_12 ,A : Tuple=16 ,A : Any=2 ,A : int=0.02 ,A : Optional[int]=3 ,A : str=4 ,A : Tuple=None ,): __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 UpperCamelCase_ ( self : int ): __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 UpperCamelCase_ ( self : Optional[int] ): return BioGptConfig( 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=A ,initializer_range=self.initializer_range ,) def UpperCamelCase_ ( self : int ,A : Optional[Any] ,A : Any ,A : Any ,A : Any ,A : int ,A : List[str] ,A : List[Any] ): __A = BioGptModel(config=A ) model.to(A ) model.eval() __A = model(A ,attention_mask=A ) __A = model(A ) self.parent.assertEqual(result.last_hidden_state.shape ,(self.batch_size, self.seq_length, self.hidden_size) ) def UpperCamelCase_ ( self : Any ,A : Tuple ,A : str ,A : Optional[Any] ,A : str ,A : Dict ,A : Dict ,A : Tuple ,A : Union[str, Any] ,A : Tuple ,): __A = BioGptForCausalLM(config=A ) model.to(A ) model.eval() __A = model(A ,attention_mask=A ,token_type_ids=A ,labels=A ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.seq_length, self.vocab_size) ) def UpperCamelCase_ ( self : Union[str, Any] ,A : int ,A : Dict ,A : Optional[Any] ,A : List[Any] ,A : Any ,*A : Optional[Any] ): __A = BioGptModel(config=A ) model.to(A ) model.eval() # create attention mask __A = torch.ones(input_ids.shape ,dtype=torch.long ,device=A ) __A = self.seq_length // 2 __A = 0 # first forward pass __A , __A = model(A ,attention_mask=A ).to_tuple() # create hypothetical next token and extent to next_input_ids __A = ids_tensor((self.batch_size, 1) ,config.vocab_size ) # change a random masked slice from input_ids __A = ids_tensor((1,) ,A ).item() + 1 __A = ids_tensor((self.batch_size, 1) ,config.vocab_size ).squeeze(-1 ) __A = random_other_next_tokens # append to next input_ids and attn_mask __A = torch.cat([input_ids, next_tokens] ,dim=-1 ) __A = torch.cat( [attn_mask, torch.ones((attn_mask.shape[0], 1) ,dtype=torch.long ,device=A )] ,dim=1 ,) # get two different outputs __A = model(A ,attention_mask=A )["last_hidden_state"] __A = model(A ,past_key_values=A ,attention_mask=A )["last_hidden_state"] # select random slice __A = ids_tensor((1,) ,output_from_past.shape[-1] ).item() __A = output_from_no_past[:, -1, random_slice_idx].detach() __A = output_from_past[:, 0, random_slice_idx].detach() # test that outputs are equal for slice self.parent.assertTrue(torch.allclose(A ,A ,atol=1E-3 ) ) def UpperCamelCase_ ( self : Dict ,A : List[str] ,A : Dict ,A : Dict ,A : Tuple ,A : Optional[int] ,*A : int ): __A = BioGptModel(config=A ).to(A ).eval() __A = torch.ones(input_ids.shape ,dtype=torch.long ,device=A ) # first forward pass __A = model(A ,attention_mask=A ,use_cache=A ) __A , __A = outputs.to_tuple() # create hypothetical multiple next token and extent to next_input_ids __A = ids_tensor((self.batch_size, 3) ,config.vocab_size ) __A = ids_tensor((self.batch_size, 3) ,2 ) # append to next input_ids and __A = torch.cat([input_ids, next_tokens] ,dim=-1 ) __A = torch.cat([attention_mask, next_attn_mask] ,dim=-1 ) __A = model(A ,attention_mask=A )["last_hidden_state"] __A = model(A ,attention_mask=A ,past_key_values=A )[ "last_hidden_state" ] # select random slice __A = ids_tensor((1,) ,output_from_past.shape[-1] ).item() __A = output_from_no_past[:, -3:, random_slice_idx].detach() __A = output_from_past[:, :, random_slice_idx].detach() self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1] ) # test that outputs are equal for slice self.parent.assertTrue(torch.allclose(A ,A ,atol=1E-3 ) ) def UpperCamelCase_ ( self : Any ,A : Union[str, Any] ,A : List[Any] ,A : str ,A : List[Any] ,A : Optional[int] ,*A : str ,A : List[Any]=False ): __A = BioGptForCausalLM(A ) model.to(A ) if gradient_checkpointing: model.gradient_checkpointing_enable() __A = model(A ,labels=A ) self.parent.assertEqual(result.loss.shape ,() ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.seq_length, self.vocab_size) ) result.loss.backward() def UpperCamelCase_ ( self : Tuple ,A : str ,*A : List[Any] ): __A = BioGptModel(A ) __A = model.config.initializer_range / math.sqrt(2 * model.config.num_hidden_layers ) for key in model.state_dict().keys(): if "c_proj" in key and "weight" in key: self.parent.assertLessEqual(abs(torch.std(model.state_dict()[key] ) - model_std ) ,0.0_01 ) self.parent.assertLessEqual(abs(torch.mean(model.state_dict()[key] ) - 0.0 ) ,0.01 ) def UpperCamelCase_ ( self : Dict ,A : str ,A : int ,A : str ,A : List[Any] ,A : str ,*A : Optional[Any] ): __A = self.num_labels __A = BioGptForTokenClassification(A ) model.to(A ) model.eval() __A = model(A ,attention_mask=A ,token_type_ids=A ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.seq_length, self.num_labels) ) def UpperCamelCase_ ( self : str ): __A = self.prepare_config_and_inputs() ( ( __A ) , ( __A ) , ( __A ) , ( __A ) , ( __A ) , ( __A ) , ( __A ) , ) = config_and_inputs __A = {"input_ids": input_ids, "attention_mask": input_mask} return config, inputs_dict @require_torch class UpperCAmelCase ( __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , unittest.TestCase ): '''simple docstring''' snake_case_ = ( (BioGptModel, BioGptForCausalLM, BioGptForSequenceClassification, BioGptForTokenClassification) if is_torch_available() else () ) snake_case_ = (BioGptForCausalLM,) if is_torch_available() else () snake_case_ = ( { "feature-extraction": BioGptModel, "text-classification": BioGptForSequenceClassification, "text-generation": BioGptForCausalLM, "token-classification": BioGptForTokenClassification, "zero-shot": BioGptForSequenceClassification, } if is_torch_available() else {} ) snake_case_ = False def UpperCamelCase_ ( self : int ): __A = BioGptModelTester(self ) __A = ConfigTester(self ,config_class=A ,hidden_size=37 ) def UpperCamelCase_ ( self : Union[str, Any] ): self.config_tester.run_common_tests() def UpperCamelCase_ ( self : Union[str, Any] ): __A = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*A ) def UpperCamelCase_ ( self : List[Any] ): __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(*A ) def UpperCamelCase_ ( self : Optional[int] ): __A = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_biogpt_model_attention_mask_past(*A ) def UpperCamelCase_ ( self : Dict ): __A = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_forward_and_backwards(*A ,gradient_checkpointing=A ) def UpperCamelCase_ ( self : Tuple ): __A = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_biogpt_model_past_large_inputs(*A ) def UpperCamelCase_ ( self : str ): __A = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_biogpt_weight_initialization(*A ) def UpperCamelCase_ ( self : Optional[Any] ): __A = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_biogpt_for_token_classification(*A ) @slow def UpperCamelCase_ ( self : List[Any] ): __A = BioGptForCausalLM.from_pretrained("microsoft/biogpt" ) model.to(A ) __A = BioGptTokenizer.from_pretrained("microsoft/biogpt" ) __A = "left" # Define PAD Token = EOS Token = 50256 __A = tokenizer.eos_token __A = model.config.eos_token_id # use different length sentences to test batching __A = [ "Hello, my dog is a little", "Today, I", ] __A = tokenizer(A ,return_tensors="pt" ,padding=A ) __A = inputs["input_ids"].to(A ) __A = model.generate( input_ids=A ,attention_mask=inputs["attention_mask"].to(A ) ,) __A = tokenizer(sentences[0] ,return_tensors="pt" ).input_ids.to(A ) __A = model.generate(input_ids=A ) __A = inputs_non_padded.shape[-1] - inputs["attention_mask"][-1].long().sum().cpu().item() __A = tokenizer(sentences[1] ,return_tensors="pt" ).input_ids.to(A ) __A = model.generate(input_ids=A ,max_length=model.config.max_length - num_paddings ) __A = tokenizer.batch_decode(A ,skip_special_tokens=A ) __A = tokenizer.decode(output_non_padded[0] ,skip_special_tokens=A ) __A = tokenizer.decode(output_padded[0] ,skip_special_tokens=A ) __A = [ "Hello, my dog is a little bit bigger than a little bit.", "Today, I have a good idea of how to use the information", ] self.assertListEqual(A ,A ) self.assertListEqual(A ,[non_padded_sentence, padded_sentence] ) @slow def UpperCamelCase_ ( self : str ): for model_name in BIOGPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: __A = BioGptModel.from_pretrained(A ) self.assertIsNotNone(A ) def UpperCamelCase_ ( self : Union[str, Any] ): __A , __A = self.model_tester.prepare_config_and_inputs_for_common() __A = 3 __A = input_dict["input_ids"] __A = input_ids.ne(1 ).to(A ) __A = ids_tensor([self.model_tester.batch_size] ,self.model_tester.type_sequence_label_size ) __A = BioGptForSequenceClassification(A ) model.to(A ) model.eval() __A = model(A ,attention_mask=A ,labels=A ) self.assertEqual(result.logits.shape ,(self.model_tester.batch_size, self.model_tester.num_labels) ) def UpperCamelCase_ ( self : List[Any] ): __A , __A = self.model_tester.prepare_config_and_inputs_for_common() __A = 3 __A = "multi_label_classification" __A = input_dict["input_ids"] __A = input_ids.ne(1 ).to(A ) __A = ids_tensor( [self.model_tester.batch_size, config.num_labels] ,self.model_tester.type_sequence_label_size ).to(torch.float ) __A = BioGptForSequenceClassification(A ) model.to(A ) model.eval() __A = model(A ,attention_mask=A ,labels=A ) self.assertEqual(result.logits.shape ,(self.model_tester.batch_size, self.model_tester.num_labels) ) @require_torch class UpperCAmelCase ( unittest.TestCase ): '''simple docstring''' @slow def UpperCamelCase_ ( self : Tuple ): __A = BioGptForCausalLM.from_pretrained("microsoft/biogpt" ) __A = torch.tensor([[2, 48_05, 9, 6_56, 21]] ) __A = model(A )[0] __A = 4_23_84 __A = torch.Size((1, 5, vocab_size) ) self.assertEqual(output.shape ,A ) __A = torch.tensor( [[[-9.52_36, -9.89_18, 10.45_57], [-11.04_69, -9.64_23, 8.10_22], [-8.86_64, -7.88_26, 5.53_25]]] ) self.assertTrue(torch.allclose(output[:, :3, :3] ,A ,atol=1E-4 ) ) @slow def UpperCamelCase_ ( self : str ): __A = BioGptTokenizer.from_pretrained("microsoft/biogpt" ) __A = BioGptForCausalLM.from_pretrained("microsoft/biogpt" ) model.to(A ) torch.manual_seed(0 ) __A = tokenizer("COVID-19 is" ,return_tensors="pt" ).to(A ) __A = model.generate( **A ,min_length=1_00 ,max_length=10_24 ,num_beams=5 ,early_stopping=A ,) __A = tokenizer.decode(output_ids[0] ,skip_special_tokens=A ) __A = ( "COVID-19 is a global pandemic caused by severe acute respiratory syndrome coronavirus 2 (SARS-CoV-2), the" " causative agent of coronavirus disease 2019 (COVID-19), which has spread to more than 200 countries and" " territories, including the United States (US), Canada, Australia, New Zealand, the United Kingdom (UK)," " and the United States of America (USA), as of March 11, 2020, with more than 800,000 confirmed cases and" " more than 800,000 deaths." ) self.assertEqual(A ,A )
15
from __future__ import annotations UpperCAmelCase__ = list[list[int]] # assigning initial values to the grid UpperCAmelCase__ = [ [3, 0, 6, 5, 0, 8, 4, 0, 0], [5, 2, 0, 0, 0, 0, 0, 0, 0], [0, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] # a grid with no solution UpperCAmelCase__ = [ [5, 0, 6, 5, 0, 8, 4, 0, 3], [5, 2, 0, 0, 0, 0, 0, 0, 2], [1, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] def A ( _UpperCAmelCase : Matrix , _UpperCAmelCase : int , _UpperCAmelCase : int , _UpperCAmelCase : int ) -> bool: '''simple docstring''' for i in range(9 ): if grid[row][i] == n or grid[i][column] == n: return False for i in range(3 ): for j in range(3 ): if grid[(row - row % 3) + i][(column - column % 3) + j] == n: return False return True def A ( _UpperCAmelCase : Matrix ) -> tuple[int, int] | None: '''simple docstring''' for i in range(9 ): for j in range(9 ): if grid[i][j] == 0: return i, j return None def A ( _UpperCAmelCase : Matrix ) -> Matrix | None: '''simple docstring''' if location := find_empty_location(_UpperCAmelCase ): _UpperCAmelCase , _UpperCAmelCase = location else: # If the location is ``None``, then the grid is solved. return grid for digit in range(1 , 10 ): if is_safe(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ): _UpperCAmelCase = digit if sudoku(_UpperCAmelCase ) is not None: return grid _UpperCAmelCase = 0 return None def A ( _UpperCAmelCase : Matrix ) -> None: '''simple docstring''' for row in grid: for cell in row: print(_UpperCAmelCase , end=' ' ) print() if __name__ == "__main__": # make a copy of grid so that you can compare with the unmodified grid for example_grid in (initial_grid, no_solution): print("\nExample grid:\n" + "=" * 20) print_solution(example_grid) print("\nExample grid solution:") UpperCAmelCase__ = sudoku(example_grid) if solution is not None: print_solution(solution) else: print("Cannot find a solution.")
339
0
"""simple docstring""" import unittest import numpy as np from transformers import DistilBertConfig, is_flax_available from transformers.testing_utils import require_flax, slow from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask if is_flax_available(): import jax.numpy as jnp from transformers.models.distilbert.modeling_flax_distilbert import ( FlaxDistilBertForMaskedLM, FlaxDistilBertForMultipleChoice, FlaxDistilBertForQuestionAnswering, FlaxDistilBertForSequenceClassification, FlaxDistilBertForTokenClassification, FlaxDistilBertModel, ) class __A ( unittest.TestCase ): '''simple docstring''' def __init__( self : Optional[int] ,_snake_case : int ,_snake_case : Tuple=13 ,_snake_case : Dict=7 ,_snake_case : Any=True ,_snake_case : Optional[Any]=True ,_snake_case : List[Any]=True ,_snake_case : Optional[int]=True ,_snake_case : Any=99 ,_snake_case : Dict=32 ,_snake_case : Optional[int]=5 ,_snake_case : List[Any]=4 ,_snake_case : Union[str, Any]=37 ,_snake_case : Dict="gelu" ,_snake_case : List[Any]=0.1 ,_snake_case : Dict=0.1 ,_snake_case : Optional[Any]=512 ,_snake_case : Dict=16 ,_snake_case : List[Any]=2 ,_snake_case : List[Any]=0.02 ,_snake_case : str=4 ,) -> Tuple: """simple docstring""" lowercase__ : Optional[int] = parent lowercase__ : str = batch_size lowercase__ : Any = seq_length lowercase__ : Union[str, Any] = is_training lowercase__ : Tuple = use_attention_mask lowercase__ : Tuple = use_token_type_ids lowercase__ : Optional[Any] = use_labels lowercase__ : Tuple = vocab_size lowercase__ : Any = hidden_size lowercase__ : Optional[Any] = num_hidden_layers lowercase__ : Dict = num_attention_heads lowercase__ : Union[str, Any] = intermediate_size lowercase__ : Tuple = hidden_act lowercase__ : List[str] = hidden_dropout_prob lowercase__ : List[str] = attention_probs_dropout_prob lowercase__ : Dict = max_position_embeddings lowercase__ : Union[str, Any] = type_vocab_size lowercase__ : Tuple = type_sequence_label_size lowercase__ : Optional[int] = initializer_range lowercase__ : str = num_choices def UpperCAmelCase ( self : Any ) -> str: """simple docstring""" lowercase__ : Optional[int] = ids_tensor([self.batch_size, self.seq_length] ,self.vocab_size ) lowercase__ : Optional[int] = None if self.use_attention_mask: lowercase__ : Optional[Any] = random_attention_mask([self.batch_size, self.seq_length] ) lowercase__ : Any = 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_=_snake_case ,) return config, input_ids, attention_mask def UpperCAmelCase ( self : Tuple ) -> Any: """simple docstring""" lowercase__ : Tuple = self.prepare_config_and_inputs() lowercase__ , lowercase__ , lowercase__ : List[str] = config_and_inputs lowercase__ : Tuple = {'''input_ids''': input_ids, '''attention_mask''': attention_mask} return config, inputs_dict @require_flax class __A ( A_ ,unittest.TestCase ): '''simple docstring''' lowerCAmelCase : Dict = ( ( FlaxDistilBertModel, FlaxDistilBertForMaskedLM, FlaxDistilBertForMultipleChoice, FlaxDistilBertForQuestionAnswering, FlaxDistilBertForSequenceClassification, FlaxDistilBertForTokenClassification, FlaxDistilBertForQuestionAnswering, ) if is_flax_available() else () ) def UpperCAmelCase ( self : Dict ) -> Tuple: """simple docstring""" lowercase__ : int = FlaxDistilBertModelTester(self ) @slow def UpperCAmelCase ( self : Optional[int] ) -> Optional[int]: """simple docstring""" for model_class_name in self.all_model_classes: lowercase__ : Union[str, Any] = model_class_name.from_pretrained('''distilbert-base-uncased''' ) lowercase__ : str = model(np.ones((1, 1) ) ) self.assertIsNotNone(_snake_case ) @require_flax class __A ( unittest.TestCase ): '''simple docstring''' @slow def UpperCAmelCase ( self : Optional[int] ) -> List[str]: """simple docstring""" lowercase__ : Tuple = FlaxDistilBertModel.from_pretrained('''distilbert-base-uncased''' ) lowercase__ : str = np.array([[0, 345, 232, 328, 740, 140, 1_695, 69, 6_078, 1_588, 2]] ) lowercase__ : Optional[Any] = np.array([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] ) lowercase__ : Optional[Any] = model(_snake_case ,attention_mask=_snake_case )[0] lowercase__ : Union[str, Any] = (1, 11, 768) self.assertEqual(output.shape ,_snake_case ) lowercase__ : Tuple = np.array([[[-0.1639, 0.3299, 0.1648], [-0.1746, 0.3289, 0.1710], [-0.1884, 0.3357, 0.1810]]] ) self.assertTrue(jnp.allclose(output[:, 1:4, 1:4] ,_snake_case ,atol=1e-4 ) )
16
import numpy as np from nltk.translate import meteor_score import datasets from datasets.config import importlib_metadata, version UpperCAmelCase__ = version.parse(importlib_metadata.version("nltk")) if NLTK_VERSION >= version.Version("3.6.4"): from nltk import word_tokenize UpperCAmelCase__ = "\\n@inproceedings{banarjee2005,\n title = {{METEOR}: An Automatic Metric for {MT} Evaluation with Improved Correlation with Human Judgments},\n author = {Banerjee, Satanjeev and Lavie, Alon},\n booktitle = {Proceedings of the {ACL} Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization},\n month = jun,\n year = {2005},\n address = {Ann Arbor, Michigan},\n publisher = {Association for Computational Linguistics},\n url = {https://www.aclweb.org/anthology/W05-0909},\n pages = {65--72},\n}\n" UpperCAmelCase__ = "\\nMETEOR, an automatic metric for machine translation evaluation\nthat is based on a generalized concept of unigram matching between the\nmachine-produced translation and human-produced reference translations.\nUnigrams can be matched based on their surface forms, stemmed forms,\nand meanings; furthermore, METEOR can be easily extended to include more\nadvanced matching strategies. Once all generalized unigram matches\nbetween the two strings have been found, METEOR computes a score for\nthis matching using a combination of unigram-precision, unigram-recall, and\na measure of fragmentation that is designed to directly capture how\nwell-ordered the matched words in the machine translation are in relation\nto the reference.\n\nMETEOR gets an R correlation value of 0.347 with human evaluation on the Arabic\ndata and 0.331 on the Chinese data. This is shown to be an improvement on\nusing simply unigram-precision, unigram-recall and their harmonic F1\ncombination.\n" UpperCAmelCase__ = "\nComputes METEOR score of translated segments against one or more references.\nArgs:\n predictions: list of predictions to score. Each prediction\n should be a string with tokens separated by spaces.\n references: list of reference for each prediction. Each\n reference should be a string with tokens separated by spaces.\n alpha: Parameter for controlling relative weights of precision and recall. default: 0.9\n beta: Parameter for controlling shape of penalty as a function of fragmentation. default: 3\n gamma: Relative weight assigned to fragmentation penalty. default: 0.5\nReturns:\n 'meteor': meteor score.\nExamples:\n\n >>> meteor = datasets.load_metric('meteor')\n >>> predictions = [\"It is a guide to action which ensures that the military always obeys the commands of the party\"]\n >>> references = [\"It is a guide to action that ensures that the military will forever heed Party commands\"]\n >>> results = meteor.compute(predictions=predictions, references=references)\n >>> print(round(results[\"meteor\"], 4))\n 0.6944\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class __lowerCAmelCase ( datasets.Metric ): def _lowerCamelCase ( self : List[Any]) -> List[Any]: """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': datasets.Value('string' , id='sequence'), 'references': datasets.Value('string' , id='sequence'), }) , codebase_urls=['https://github.com/nltk/nltk/blob/develop/nltk/translate/meteor_score.py'] , reference_urls=[ 'https://www.nltk.org/api/nltk.translate.html#module-nltk.translate.meteor_score', 'https://en.wikipedia.org/wiki/METEOR', ] , ) def _lowerCamelCase ( self : Optional[Any] , A : List[str]) -> List[Any]: """simple docstring""" import nltk nltk.download('wordnet') if NLTK_VERSION >= version.Version('3.6.5'): nltk.download('punkt') if NLTK_VERSION >= version.Version('3.6.6'): nltk.download('omw-1.4') def _lowerCamelCase ( self : Optional[Any] , A : Tuple , A : Optional[int] , A : List[Any]=0.9 , A : Optional[Any]=3 , A : Optional[int]=0.5) -> Any: """simple docstring""" if NLTK_VERSION >= version.Version('3.6.5'): _UpperCAmelCase = [ meteor_score.single_meteor_score( word_tokenize(A) , word_tokenize(A) , alpha=A , beta=A , gamma=A) for ref, pred in zip(A , A) ] else: _UpperCAmelCase = [ meteor_score.single_meteor_score(A , A , alpha=A , beta=A , gamma=A) for ref, pred in zip(A , A) ] return {"meteor": np.mean(A)}
339
0
"""simple docstring""" def _A ( UpperCamelCase_ : int, UpperCamelCase_ : int) -> int: '''simple docstring''' return int(input_a == input_a == 0) def _A ( ) -> None: '''simple docstring''' print("Truth Table of NOR Gate:") print("| Input 1 | Input 2 | Output |") print(F"""| 0 | 0 | {nor_gate(0, 0)} |""") print(F"""| 0 | 1 | {nor_gate(0, 1)} |""") print(F"""| 1 | 0 | {nor_gate(1, 0)} |""") print(F"""| 1 | 1 | {nor_gate(1, 1)} |""") if __name__ == "__main__": import doctest doctest.testmod() main()
17
import argparse import hashlib import os import urllib import warnings import torch from torch import nn from tqdm import tqdm from transformers import WhisperConfig, WhisperForConditionalGeneration UpperCAmelCase__ = { "tiny.en": "https://openaipublic.azureedge.net/main/whisper/models/d3dd57d32accea0b295c96e26691aa14d8822fac7d9d27d5dc00b4ca2826dd03/tiny.en.pt", "tiny": "https://openaipublic.azureedge.net/main/whisper/models/65147644a518d12f04e32d6f3b26facc3f8dd46e5390956a9424a650c0ce22b9/tiny.pt", "base.en": "https://openaipublic.azureedge.net/main/whisper/models/25a8566e1d0c1e2231d1c762132cd20e0f96a85d16145c3a00adf5d1ac670ead/base.en.pt", "base": "https://openaipublic.azureedge.net/main/whisper/models/ed3a0b6b1c0edf879ad9b11b1af5a0e6ab5db9205f891f668f8b0e6c6326e34e/base.pt", "small.en": "https://openaipublic.azureedge.net/main/whisper/models/f953ad0fd29cacd07d5a9eda5624af0f6bcf2258be67c92b79389873d91e0872/small.en.pt", "small": "https://openaipublic.azureedge.net/main/whisper/models/9ecf779972d90ba49c06d968637d720dd632c55bbf19d441fb42bf17a411e794/small.pt", "medium.en": "https://openaipublic.azureedge.net/main/whisper/models/d7440d1dc186f76616474e0ff0b3b6b879abc9d1a4926b7adfa41db2d497ab4f/medium.en.pt", "medium": "https://openaipublic.azureedge.net/main/whisper/models/345ae4da62f9b3d59415adc60127b97c714f32e89e936602e85993674d08dcb1/medium.pt", "large": "https://openaipublic.azureedge.net/main/whisper/models/e4b87e7e0bf463eb8e6956e646f1e277e901512310def2c24bf0e11bd3c28e9a/large.pt", "large-v2": "https://openaipublic.azureedge.net/main/whisper/models/81f7c96c852ee8fc832187b0132e569d6c3065a3252ed18e56effd0b6a73e524/large-v2.pt", } def A ( _UpperCAmelCase : Optional[int] ) -> str: '''simple docstring''' _UpperCAmelCase = ['layers', 'blocks'] for k in ignore_keys: state_dict.pop(_UpperCAmelCase , _UpperCAmelCase ) UpperCAmelCase__ = { "blocks": "layers", "mlp.0": "fc1", "mlp.2": "fc2", "mlp_ln": "final_layer_norm", ".attn.query": ".self_attn.q_proj", ".attn.key": ".self_attn.k_proj", ".attn.value": ".self_attn.v_proj", ".attn_ln": ".self_attn_layer_norm", ".attn.out": ".self_attn.out_proj", ".cross_attn.query": ".encoder_attn.q_proj", ".cross_attn.key": ".encoder_attn.k_proj", ".cross_attn.value": ".encoder_attn.v_proj", ".cross_attn_ln": ".encoder_attn_layer_norm", ".cross_attn.out": ".encoder_attn.out_proj", "decoder.ln.": "decoder.layer_norm.", "encoder.ln.": "encoder.layer_norm.", "token_embedding": "embed_tokens", "encoder.positional_embedding": "encoder.embed_positions.weight", "decoder.positional_embedding": "decoder.embed_positions.weight", "ln_post": "layer_norm", } def A ( _UpperCAmelCase : Dict ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = list(s_dict.keys() ) for key in keys: _UpperCAmelCase = key for k, v in WHISPER_MAPPING.items(): if k in key: _UpperCAmelCase = new_key.replace(_UpperCAmelCase , _UpperCAmelCase ) print(F"{key} -> {new_key}" ) _UpperCAmelCase = s_dict.pop(_UpperCAmelCase ) return s_dict def A ( _UpperCAmelCase : List[Any] ) -> Union[str, Any]: '''simple docstring''' _UpperCAmelCase , _UpperCAmelCase = emb.weight.shape _UpperCAmelCase = nn.Linear(_UpperCAmelCase , _UpperCAmelCase , bias=_UpperCAmelCase ) _UpperCAmelCase = emb.weight.data return lin_layer def A ( _UpperCAmelCase : str , _UpperCAmelCase : str ) -> bytes: '''simple docstring''' os.makedirs(_UpperCAmelCase , exist_ok=_UpperCAmelCase ) _UpperCAmelCase = os.path.basename(_UpperCAmelCase ) _UpperCAmelCase = url.split('/' )[-2] _UpperCAmelCase = os.path.join(_UpperCAmelCase , _UpperCAmelCase ) if os.path.exists(_UpperCAmelCase ) and not os.path.isfile(_UpperCAmelCase ): raise RuntimeError(F"{download_target} exists and is not a regular file" ) if os.path.isfile(_UpperCAmelCase ): _UpperCAmelCase = open(_UpperCAmelCase , 'rb' ).read() if hashlib.shaaaa(_UpperCAmelCase ).hexdigest() == expected_shaaaa: return model_bytes else: warnings.warn(F"{download_target} exists, but the SHA256 checksum does not match; re-downloading the file" ) with urllib.request.urlopen(_UpperCAmelCase ) as source, open(_UpperCAmelCase , 'wb' ) as output: with tqdm( total=int(source.info().get('Content-Length' ) ) , ncols=80 , unit='iB' , unit_scale=_UpperCAmelCase , unit_divisor=1_024 ) as loop: while True: _UpperCAmelCase = source.read(8_192 ) if not buffer: break output.write(_UpperCAmelCase ) loop.update(len(_UpperCAmelCase ) ) _UpperCAmelCase = open(_UpperCAmelCase , 'rb' ).read() if hashlib.shaaaa(_UpperCAmelCase ).hexdigest() != expected_shaaaa: raise RuntimeError( 'Model has been downloaded but the SHA256 checksum does not not match. Please retry loading the model.' ) return model_bytes def A ( _UpperCAmelCase : List[Any] , _UpperCAmelCase : Any ) -> Optional[int]: '''simple docstring''' if ".pt" not in checkpoint_path: _UpperCAmelCase = _download(_MODELS[checkpoint_path] ) else: _UpperCAmelCase = torch.load(_UpperCAmelCase , map_location='cpu' ) _UpperCAmelCase = original_checkpoint['dims'] _UpperCAmelCase = original_checkpoint['model_state_dict'] _UpperCAmelCase = state_dict['decoder.token_embedding.weight'] remove_ignore_keys_(_UpperCAmelCase ) rename_keys(_UpperCAmelCase ) _UpperCAmelCase = True _UpperCAmelCase = state_dict['decoder.layers.0.fc1.weight'].shape[0] _UpperCAmelCase = WhisperConfig( vocab_size=dimensions['n_vocab'] , encoder_ffn_dim=_UpperCAmelCase , decoder_ffn_dim=_UpperCAmelCase , num_mel_bins=dimensions['n_mels'] , d_model=dimensions['n_audio_state'] , max_target_positions=dimensions['n_text_ctx'] , encoder_layers=dimensions['n_audio_layer'] , encoder_attention_heads=dimensions['n_audio_head'] , decoder_layers=dimensions['n_text_layer'] , decoder_attention_heads=dimensions['n_text_state'] , max_source_positions=dimensions['n_audio_ctx'] , ) _UpperCAmelCase = WhisperForConditionalGeneration(_UpperCAmelCase ) _UpperCAmelCase , _UpperCAmelCase = model.model.load_state_dict(_UpperCAmelCase , strict=_UpperCAmelCase ) if len(_UpperCAmelCase ) > 0 and not set(_UpperCAmelCase ) <= { "encoder.embed_positions.weights", "decoder.embed_positions.weights", }: raise ValueError( 'Only `encoder.embed_positions.weights` and `decoder.embed_positions.weights` are allowed to be missing,' F" but all the following weights are missing {missing}" ) if tie_embeds: _UpperCAmelCase = make_linear_from_emb(model.model.decoder.embed_tokens ) else: _UpperCAmelCase = proj_out_weights model.save_pretrained(_UpperCAmelCase ) if __name__ == "__main__": UpperCAmelCase__ = argparse.ArgumentParser() # # Required parameters parser.add_argument("--checkpoint_path", type=str, help="Patht to the downloaded checkpoints") parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.") UpperCAmelCase__ = parser.parse_args() convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)
339
0
import unittest import numpy as np from transformers.testing_utils import require_flax, require_tf, require_torch from transformers.utils import ( expand_dims, flatten_dict, is_flax_available, is_tf_available, is_torch_available, reshape, squeeze, transpose, ) if is_flax_available(): import jax.numpy as jnp if is_tf_available(): import tensorflow as tf if is_torch_available(): import torch class a__ ( unittest.TestCase ): def __UpperCamelCase ( self : List[str] ): """simple docstring""" SCREAMING_SNAKE_CASE_ : Dict = { "task_specific_params": { "summarization": {"length_penalty": 1.0, "max_length": 128, "min_length": 12, "num_beams": 4}, "summarization_cnn": {"length_penalty": 2.0, "max_length": 142, "min_length": 56, "num_beams": 4}, "summarization_xsum": {"length_penalty": 1.0, "max_length": 62, "min_length": 11, "num_beams": 6}, } } SCREAMING_SNAKE_CASE_ : Any = { "task_specific_params.summarization.length_penalty": 1.0, "task_specific_params.summarization.max_length": 128, "task_specific_params.summarization.min_length": 12, "task_specific_params.summarization.num_beams": 4, "task_specific_params.summarization_cnn.length_penalty": 2.0, "task_specific_params.summarization_cnn.max_length": 142, "task_specific_params.summarization_cnn.min_length": 56, "task_specific_params.summarization_cnn.num_beams": 4, "task_specific_params.summarization_xsum.length_penalty": 1.0, "task_specific_params.summarization_xsum.max_length": 62, "task_specific_params.summarization_xsum.min_length": 11, "task_specific_params.summarization_xsum.num_beams": 6, } self.assertEqual(flatten_dict(_A ),_A ) def __UpperCamelCase ( self : str ): """simple docstring""" SCREAMING_SNAKE_CASE_ : Dict = np.random.randn(3,4 ) self.assertTrue(np.allclose(transpose(_A ),x.transpose() ) ) SCREAMING_SNAKE_CASE_ : Tuple = np.random.randn(3,4,5 ) self.assertTrue(np.allclose(transpose(_A,axes=(1, 2, 0) ),x.transpose((1, 2, 0) ) ) ) @require_torch def __UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE_ : List[str] = np.random.randn(3,4 ) SCREAMING_SNAKE_CASE_ : Any = torch.tensor(_A ) self.assertTrue(np.allclose(transpose(_A ),transpose(_A ).numpy() ) ) SCREAMING_SNAKE_CASE_ : Dict = np.random.randn(3,4,5 ) SCREAMING_SNAKE_CASE_ : Tuple = torch.tensor(_A ) self.assertTrue(np.allclose(transpose(_A,axes=(1, 2, 0) ),transpose(_A,axes=(1, 2, 0) ).numpy() ) ) @require_tf def __UpperCamelCase ( self : List[str] ): """simple docstring""" SCREAMING_SNAKE_CASE_ : Tuple = np.random.randn(3,4 ) SCREAMING_SNAKE_CASE_ : Optional[Any] = tf.constant(_A ) self.assertTrue(np.allclose(transpose(_A ),transpose(_A ).numpy() ) ) SCREAMING_SNAKE_CASE_ : List[str] = np.random.randn(3,4,5 ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = tf.constant(_A ) self.assertTrue(np.allclose(transpose(_A,axes=(1, 2, 0) ),transpose(_A,axes=(1, 2, 0) ).numpy() ) ) @require_flax def __UpperCamelCase ( self : List[str] ): """simple docstring""" SCREAMING_SNAKE_CASE_ : str = np.random.randn(3,4 ) SCREAMING_SNAKE_CASE_ : Tuple = jnp.array(_A ) self.assertTrue(np.allclose(transpose(_A ),np.asarray(transpose(_A ) ) ) ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = np.random.randn(3,4,5 ) SCREAMING_SNAKE_CASE_ : List[Any] = jnp.array(_A ) self.assertTrue(np.allclose(transpose(_A,axes=(1, 2, 0) ),np.asarray(transpose(_A,axes=(1, 2, 0) ) ) ) ) def __UpperCamelCase ( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE_ : Tuple = np.random.randn(3,4 ) self.assertTrue(np.allclose(reshape(_A,(4, 3) ),np.reshape(_A,(4, 3) ) ) ) SCREAMING_SNAKE_CASE_ : Any = np.random.randn(3,4,5 ) self.assertTrue(np.allclose(reshape(_A,(12, 5) ),np.reshape(_A,(12, 5) ) ) ) @require_torch def __UpperCamelCase ( self : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE_ : List[Any] = np.random.randn(3,4 ) SCREAMING_SNAKE_CASE_ : List[str] = torch.tensor(_A ) self.assertTrue(np.allclose(reshape(_A,(4, 3) ),reshape(_A,(4, 3) ).numpy() ) ) SCREAMING_SNAKE_CASE_ : Dict = np.random.randn(3,4,5 ) SCREAMING_SNAKE_CASE_ : int = torch.tensor(_A ) self.assertTrue(np.allclose(reshape(_A,(12, 5) ),reshape(_A,(12, 5) ).numpy() ) ) @require_tf def __UpperCamelCase ( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE_ : List[Any] = np.random.randn(3,4 ) SCREAMING_SNAKE_CASE_ : Optional[Any] = tf.constant(_A ) self.assertTrue(np.allclose(reshape(_A,(4, 3) ),reshape(_A,(4, 3) ).numpy() ) ) SCREAMING_SNAKE_CASE_ : int = np.random.randn(3,4,5 ) SCREAMING_SNAKE_CASE_ : Any = tf.constant(_A ) self.assertTrue(np.allclose(reshape(_A,(12, 5) ),reshape(_A,(12, 5) ).numpy() ) ) @require_flax def __UpperCamelCase ( self : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE_ : List[str] = np.random.randn(3,4 ) SCREAMING_SNAKE_CASE_ : int = jnp.array(_A ) self.assertTrue(np.allclose(reshape(_A,(4, 3) ),np.asarray(reshape(_A,(4, 3) ) ) ) ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = np.random.randn(3,4,5 ) SCREAMING_SNAKE_CASE_ : Tuple = jnp.array(_A ) self.assertTrue(np.allclose(reshape(_A,(12, 5) ),np.asarray(reshape(_A,(12, 5) ) ) ) ) def __UpperCamelCase ( self : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE_ : int = np.random.randn(1,3,4 ) self.assertTrue(np.allclose(squeeze(_A ),np.squeeze(_A ) ) ) SCREAMING_SNAKE_CASE_ : Any = np.random.randn(1,4,1,5 ) self.assertTrue(np.allclose(squeeze(_A,axis=2 ),np.squeeze(_A,axis=2 ) ) ) @require_torch def __UpperCamelCase ( self : List[str] ): """simple docstring""" SCREAMING_SNAKE_CASE_ : List[str] = np.random.randn(1,3,4 ) SCREAMING_SNAKE_CASE_ : Any = torch.tensor(_A ) self.assertTrue(np.allclose(squeeze(_A ),squeeze(_A ).numpy() ) ) SCREAMING_SNAKE_CASE_ : Any = np.random.randn(1,4,1,5 ) SCREAMING_SNAKE_CASE_ : Dict = torch.tensor(_A ) self.assertTrue(np.allclose(squeeze(_A,axis=2 ),squeeze(_A,axis=2 ).numpy() ) ) @require_tf def __UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE_ : str = np.random.randn(1,3,4 ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = tf.constant(_A ) self.assertTrue(np.allclose(squeeze(_A ),squeeze(_A ).numpy() ) ) SCREAMING_SNAKE_CASE_ : Any = np.random.randn(1,4,1,5 ) SCREAMING_SNAKE_CASE_ : Optional[int] = tf.constant(_A ) self.assertTrue(np.allclose(squeeze(_A,axis=2 ),squeeze(_A,axis=2 ).numpy() ) ) @require_flax def __UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE_ : List[Any] = np.random.randn(1,3,4 ) SCREAMING_SNAKE_CASE_ : List[str] = jnp.array(_A ) self.assertTrue(np.allclose(squeeze(_A ),np.asarray(squeeze(_A ) ) ) ) SCREAMING_SNAKE_CASE_ : str = np.random.randn(1,4,1,5 ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = jnp.array(_A ) self.assertTrue(np.allclose(squeeze(_A,axis=2 ),np.asarray(squeeze(_A,axis=2 ) ) ) ) def __UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE_ : Tuple = np.random.randn(3,4 ) self.assertTrue(np.allclose(expand_dims(_A,axis=1 ),np.expand_dims(_A,axis=1 ) ) ) @require_torch def __UpperCamelCase ( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE_ : Tuple = np.random.randn(3,4 ) SCREAMING_SNAKE_CASE_ : List[Any] = torch.tensor(_A ) self.assertTrue(np.allclose(expand_dims(_A,axis=1 ),expand_dims(_A,axis=1 ).numpy() ) ) @require_tf def __UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE_ : List[Any] = np.random.randn(3,4 ) SCREAMING_SNAKE_CASE_ : Optional[int] = tf.constant(_A ) self.assertTrue(np.allclose(expand_dims(_A,axis=1 ),expand_dims(_A,axis=1 ).numpy() ) ) @require_flax def __UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE_ : int = np.random.randn(3,4 ) SCREAMING_SNAKE_CASE_ : Union[str, Any] = jnp.array(_A ) self.assertTrue(np.allclose(expand_dims(_A,axis=1 ),np.asarray(expand_dims(_A,axis=1 ) ) ) )
18
from typing import List import datasets from datasets.tasks import AudioClassification from ..folder_based_builder import folder_based_builder UpperCAmelCase__ = datasets.utils.logging.get_logger(__name__) class __lowerCAmelCase ( folder_based_builder.FolderBasedBuilderConfig ): UpperCamelCase = None UpperCamelCase = None class __lowerCAmelCase ( folder_based_builder.FolderBasedBuilder ): UpperCamelCase = datasets.Audio() UpperCamelCase = '''audio''' UpperCamelCase = AudioFolderConfig UpperCamelCase = 42 # definition at the bottom of the script UpperCamelCase = AudioClassification(audio_column='''audio''' , label_column='''label''' ) UpperCAmelCase__ = [ ".aiff", ".au", ".avr", ".caf", ".flac", ".htk", ".svx", ".mat4", ".mat5", ".mpc2k", ".ogg", ".paf", ".pvf", ".raw", ".rf64", ".sd2", ".sds", ".ircam", ".voc", ".w64", ".wav", ".nist", ".wavex", ".wve", ".xi", ".mp3", ".opus", ] UpperCAmelCase__ = AUDIO_EXTENSIONS
339
0
import os import tempfile from functools import partial from unittest import TestCase from unittest.mock import patch import numpy as np import pytest from datasets.arrow_dataset import Dataset from datasets.search import ElasticSearchIndex, FaissIndex, MissingIndex from .utils import require_elasticsearch, require_faiss __A =pytest.mark.integration @require_faiss class _SCREAMING_SNAKE_CASE ( snake_case_ ): def SCREAMING_SNAKE_CASE_( self ) -> List[str]: lowerCamelCase_ = Dataset.from_dict({"filename": ["my_name-train" + "_" + str(lowercase ) for x in np.arange(30 ).tolist()]} ) return dset def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: import faiss lowerCamelCase_ = self._create_dummy_dataset() lowerCamelCase_ = dset.map( lambda lowercase , lowercase : {"vecs": i * np.ones(5 , dtype=np.floataa )} , with_indices=lowercase , keep_in_memory=lowercase ) lowerCamelCase_ = dset.add_faiss_index("vecs" , batch_size=100 , metric_type=faiss.METRIC_INNER_PRODUCT ) lowerCamelCase_ , lowerCamelCase_ = dset.get_nearest_examples("vecs" , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples["filename"][0] , "my_name-train_29" ) dset.drop_index("vecs" ) def SCREAMING_SNAKE_CASE_( self ) -> Dict: import faiss lowerCamelCase_ = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name="vecs" , batch_size=100 , metric_type=faiss.METRIC_INNER_PRODUCT , ) lowerCamelCase_ , lowerCamelCase_ = dset.get_nearest_examples("vecs" , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples["filename"][0] , "my_name-train_29" ) def SCREAMING_SNAKE_CASE_( self ) -> Optional[int]: import faiss lowerCamelCase_ = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name="vecs" , metric_type=faiss.METRIC_INNER_PRODUCT , ) # Setting delete=False and unlinking manually is not pretty... but it is required on Windows to # ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue. # see https://bugs.python.org/issue14243 and # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515 with tempfile.NamedTemporaryFile(delete=lowercase ) as tmp_file: dset.save_faiss_index("vecs" , tmp_file.name ) dset.load_faiss_index("vecs2" , tmp_file.name ) os.unlink(tmp_file.name ) lowerCamelCase_ , lowerCamelCase_ = dset.get_nearest_examples("vecs2" , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples["filename"][0] , "my_name-train_29" ) def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: lowerCamelCase_ = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name="vecs" ) dset.drop_index("vecs" ) self.assertRaises(lowercase , partial(dset.get_nearest_examples , "vecs2" , np.ones(5 , dtype=np.floataa ) ) ) def SCREAMING_SNAKE_CASE_( self ) -> Optional[int]: from elasticsearch import Elasticsearch lowerCamelCase_ = self._create_dummy_dataset() with patch("elasticsearch.Elasticsearch.search" ) as mocked_search, patch( "elasticsearch.client.IndicesClient.create" ) as mocked_index_create, patch("elasticsearch.helpers.streaming_bulk" ) as mocked_bulk: lowerCamelCase_ = {"acknowledged": True} mocked_bulk.return_value([(True, None)] * 30 ) lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 29}]}} lowerCamelCase_ = Elasticsearch() dset.add_elasticsearch_index("filename" , es_client=lowercase ) lowerCamelCase_ , lowerCamelCase_ = dset.get_nearest_examples("filename" , "my_name-train_29" ) self.assertEqual(examples["filename"][0] , "my_name-train_29" ) @require_faiss class _SCREAMING_SNAKE_CASE ( snake_case_ ): def SCREAMING_SNAKE_CASE_( self ) -> Tuple: import faiss lowerCamelCase_ = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) # add vectors index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsNotNone(index.faiss_index ) self.assertEqual(index.faiss_index.ntotal , 5 ) index.add_vectors(np.zeros((5, 5) , dtype=np.floataa ) ) self.assertEqual(index.faiss_index.ntotal , 10 ) # single query lowerCamelCase_ = np.zeros(5 , dtype=np.floataa ) lowerCamelCase_ = 1 lowerCamelCase_ , lowerCamelCase_ = index.search(lowercase ) self.assertRaises(lowercase , index.search , query.reshape(-1 , 1 ) ) self.assertGreater(scores[0] , 0 ) self.assertEqual(indices[0] , 1 ) # batched queries lowerCamelCase_ = np.eye(5 , dtype=np.floataa )[::-1] lowerCamelCase_ , lowerCamelCase_ = index.search_batch(lowercase ) self.assertRaises(lowercase , index.search_batch , queries[0] ) lowerCamelCase_ = [scores[0] for scores in total_scores] lowerCamelCase_ = [indices[0] for indices in total_indices] self.assertGreater(np.min(lowercase ) , 0 ) self.assertListEqual([4, 3, 2, 1, 0] , lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Any: import faiss lowerCamelCase_ = FaissIndex(string_factory="Flat" ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexFlat ) lowerCamelCase_ = FaissIndex(string_factory="LSH" ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexLSH ) with self.assertRaises(lowercase ): lowerCamelCase_ = FaissIndex(string_factory="Flat" , custom_index=faiss.IndexFlat(5 ) ) def SCREAMING_SNAKE_CASE_( self ) -> Optional[int]: import faiss lowerCamelCase_ = faiss.IndexFlat(5 ) lowerCamelCase_ = FaissIndex(custom_index=lowercase ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexFlat ) def SCREAMING_SNAKE_CASE_( self ) -> List[str]: import faiss lowerCamelCase_ = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) # Setting delete=False and unlinking manually is not pretty... but it is required on Windows to # ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue. # see https://bugs.python.org/issue14243 and # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515 with tempfile.NamedTemporaryFile(delete=lowercase ) as tmp_file: index.save(tmp_file.name ) lowerCamelCase_ = FaissIndex.load(tmp_file.name ) os.unlink(tmp_file.name ) lowerCamelCase_ = np.zeros(5 , dtype=np.floataa ) lowerCamelCase_ = 1 lowerCamelCase_ , lowerCamelCase_ = index.search(lowercase ) self.assertGreater(scores[0] , 0 ) self.assertEqual(indices[0] , 1 ) @require_faiss def lowerCamelCase_ ( lowerCamelCase__ ): import faiss lowerCamelCase_ = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) lowerCamelCase_ = "index.faiss" lowerCamelCase_ = F'mock://{index_name}' index.save(lowerCamelCase__ , storage_options=mockfs.storage_options ) lowerCamelCase_ = FaissIndex.load(lowerCamelCase__ , storage_options=mockfs.storage_options ) lowerCamelCase_ = np.zeros(5 , dtype=np.floataa ) lowerCamelCase_ = 1 lowerCamelCase_ , lowerCamelCase_ = index.search(lowerCamelCase__ ) assert scores[0] > 0 assert indices[0] == 1 @require_elasticsearch class _SCREAMING_SNAKE_CASE ( snake_case_ ): def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: from elasticsearch import Elasticsearch with patch("elasticsearch.Elasticsearch.search" ) as mocked_search, patch( "elasticsearch.client.IndicesClient.create" ) as mocked_index_create, patch("elasticsearch.helpers.streaming_bulk" ) as mocked_bulk: lowerCamelCase_ = Elasticsearch() lowerCamelCase_ = {"acknowledged": True} lowerCamelCase_ = ElasticSearchIndex(es_client=lowercase ) mocked_bulk.return_value([(True, None)] * 3 ) index.add_documents(["foo", "bar", "foobar"] ) # single query lowerCamelCase_ = "foo" lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 0}]}} lowerCamelCase_ , lowerCamelCase_ = index.search(lowercase ) self.assertEqual(scores[0] , 1 ) self.assertEqual(indices[0] , 0 ) # single query with timeout lowerCamelCase_ = "foo" lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 0}]}} lowerCamelCase_ , lowerCamelCase_ = index.search(lowercase , request_timeout=30 ) self.assertEqual(scores[0] , 1 ) self.assertEqual(indices[0] , 0 ) # batched queries lowerCamelCase_ = ["foo", "bar", "foobar"] lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 1}]}} lowerCamelCase_ , lowerCamelCase_ = index.search_batch(lowercase ) lowerCamelCase_ = [scores[0] for scores in total_scores] lowerCamelCase_ = [indices[0] for indices in total_indices] self.assertGreater(np.min(lowercase ) , 0 ) self.assertListEqual([1, 1, 1] , lowercase ) # batched queries with timeout lowerCamelCase_ = ["foo", "bar", "foobar"] lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 1}]}} lowerCamelCase_ , lowerCamelCase_ = index.search_batch(lowercase , request_timeout=30 ) lowerCamelCase_ = [scores[0] for scores in total_scores] lowerCamelCase_ = [indices[0] for indices in total_indices] self.assertGreater(np.min(lowercase ) , 0 ) self.assertListEqual([1, 1, 1] , lowercase )
19
import sys from collections import defaultdict class __lowerCAmelCase : def __init__( self : int) -> str: """simple docstring""" _UpperCAmelCase = [] def _lowerCamelCase ( self : Any , A : List[str]) -> int: """simple docstring""" return self.node_position[vertex] def _lowerCamelCase ( self : Optional[Any] , A : Optional[int] , A : str) -> List[str]: """simple docstring""" _UpperCAmelCase = pos def _lowerCamelCase ( self : Tuple , A : Tuple , A : Dict , A : List[str] , A : Optional[Any]) -> Dict: """simple docstring""" if start > size // 2 - 1: return else: if 2 * start + 2 >= size: _UpperCAmelCase = 2 * start + 1 else: if heap[2 * start + 1] < heap[2 * start + 2]: _UpperCAmelCase = 2 * start + 1 else: _UpperCAmelCase = 2 * start + 2 if heap[smallest_child] < heap[start]: _UpperCAmelCase , _UpperCAmelCase = heap[smallest_child], positions[smallest_child] _UpperCAmelCase , _UpperCAmelCase = ( heap[start], positions[start], ) _UpperCAmelCase , _UpperCAmelCase = temp, tempa _UpperCAmelCase = self.get_position(positions[smallest_child]) self.set_position( positions[smallest_child] , self.get_position(positions[start])) self.set_position(positions[start] , A) self.top_to_bottom(A , A , A , A) def _lowerCamelCase ( self : Optional[int] , A : str , A : Optional[Any] , A : Optional[int] , A : str) -> Any: """simple docstring""" _UpperCAmelCase = position[index] while index != 0: _UpperCAmelCase = int((index - 2) / 2) if index % 2 == 0 else int((index - 1) / 2) if val < heap[parent]: _UpperCAmelCase = heap[parent] _UpperCAmelCase = position[parent] self.set_position(position[parent] , A) else: _UpperCAmelCase = val _UpperCAmelCase = temp self.set_position(A , A) break _UpperCAmelCase = parent else: _UpperCAmelCase = val _UpperCAmelCase = temp self.set_position(A , 0) def _lowerCamelCase ( self : Union[str, Any] , A : Optional[int] , A : Tuple) -> str: """simple docstring""" _UpperCAmelCase = len(A) // 2 - 1 for i in range(A , -1 , -1): self.top_to_bottom(A , A , len(A) , A) def _lowerCamelCase ( self : Optional[int] , A : int , A : str) -> List[str]: """simple docstring""" _UpperCAmelCase = positions[0] _UpperCAmelCase = sys.maxsize self.top_to_bottom(A , 0 , len(A) , A) return temp def A ( _UpperCAmelCase : int ) -> Any: '''simple docstring''' _UpperCAmelCase = Heap() _UpperCAmelCase = [0] * len(_UpperCAmelCase ) _UpperCAmelCase = [-1] * len(_UpperCAmelCase ) # Neighboring Tree Vertex of selected vertex # Minimum Distance of explored vertex with neighboring vertex of partial tree # formed in graph _UpperCAmelCase = [] # Heap of Distance of vertices from their neighboring vertex _UpperCAmelCase = [] for vertex in range(len(_UpperCAmelCase ) ): distance_tv.append(sys.maxsize ) positions.append(_UpperCAmelCase ) heap.node_position.append(_UpperCAmelCase ) _UpperCAmelCase = [] _UpperCAmelCase = 1 _UpperCAmelCase = sys.maxsize for neighbor, distance in adjacency_list[0]: _UpperCAmelCase = 0 _UpperCAmelCase = distance heap.heapify(_UpperCAmelCase , _UpperCAmelCase ) for _ in range(1 , len(_UpperCAmelCase ) ): _UpperCAmelCase = heap.delete_minimum(_UpperCAmelCase , _UpperCAmelCase ) if visited[vertex] == 0: tree_edges.append((nbr_tv[vertex], vertex) ) _UpperCAmelCase = 1 for neighbor, distance in adjacency_list[vertex]: if ( visited[neighbor] == 0 and distance < distance_tv[heap.get_position(_UpperCAmelCase )] ): _UpperCAmelCase = distance heap.bottom_to_top( _UpperCAmelCase , heap.get_position(_UpperCAmelCase ) , _UpperCAmelCase , _UpperCAmelCase ) _UpperCAmelCase = vertex return tree_edges if __name__ == "__main__": # pragma: no cover # < --------- Prims Algorithm --------- > UpperCAmelCase__ = int(input("Enter number of edges: ").strip()) UpperCAmelCase__ = defaultdict(list) for _ in range(edges_number): UpperCAmelCase__ = [int(x) for x in input().strip().split()] adjacency_list[edge[0]].append([edge[1], edge[2]]) adjacency_list[edge[1]].append([edge[0], edge[2]]) print(prisms_algorithm(adjacency_list))
339
0
import mpmath # for roots of unity import numpy as np class __snake_case : def __init__( self ,snake_case=None ,snake_case=None ): '''simple docstring''' lowercase : List[str] = list(poly_a or [0] )[:] lowercase : List[str] = list(poly_b or [0] )[:] # Remove leading zero coefficients while self.polyA[-1] == 0: self.polyA.pop() lowercase : Any = len(self.polyA ) while self.polyB[-1] == 0: self.polyB.pop() lowercase : List[str] = len(self.polyB ) # Add 0 to make lengths equal a power of 2 lowercase : str = int( 2 ** np.ceil(np.loga(len(self.polyA ) + len(self.polyB ) - 1 ) ) ) while len(self.polyA ) < self.c_max_length: self.polyA.append(0 ) while len(self.polyB ) < self.c_max_length: self.polyB.append(0 ) # A complex root used for the fourier transform lowercase : Union[str, Any] = complex(mpmath.root(x=1 ,n=self.c_max_length ,k=1 ) ) # The product lowercase : Any = self.__multiply() def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Union[str, Any] = [[x] for x in self.polyA] if which == """A""" else [[x] for x in self.polyB] # Corner case if len(snake_case ) <= 1: return dft[0] # lowercase : Optional[Any] = self.c_max_length // 2 while next_ncol > 0: lowercase : Tuple = [[] for i in range(snake_case )] lowercase : int = self.root**next_ncol # First half of next step lowercase : Tuple = 1 for j in range(self.c_max_length // (next_ncol * 2) ): for i in range(snake_case ): new_dft[i].append(dft[i][j] + current_root * dft[i + next_ncol][j] ) current_root *= root # Second half of next step lowercase : Any = 1 for j in range(self.c_max_length // (next_ncol * 2) ): for i in range(snake_case ): new_dft[i].append(dft[i][j] - current_root * dft[i + next_ncol][j] ) current_root *= root # Update lowercase : Dict = new_dft lowercase : Optional[int] = next_ncol // 2 return dft[0] def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = self.__dft("""A""" ) lowercase : List[str] = self.__dft("""B""" ) lowercase : Optional[int] = [[dft_a[i] * dft_b[i] for i in range(self.c_max_length )]] del dft_a del dft_b # Corner Case if len(inverce_c[0] ) <= 1: return inverce_c[0] # Inverse DFT lowercase : Dict = 2 while next_ncol <= self.c_max_length: lowercase : Any = [[] for i in range(snake_case )] lowercase : Optional[Any] = self.root ** (next_ncol // 2) lowercase : Optional[int] = 1 # First half of next step for j in range(self.c_max_length // next_ncol ): for i in range(next_ncol // 2 ): # Even positions new_inverse_c[i].append( ( inverce_c[i][j] + inverce_c[i][j + self.c_max_length // next_ncol] ) / 2 ) # Odd positions new_inverse_c[i + next_ncol // 2].append( ( inverce_c[i][j] - inverce_c[i][j + self.c_max_length // next_ncol] ) / (2 * current_root) ) current_root *= root # Update lowercase : str = new_inverse_c next_ncol *= 2 # Unpack lowercase : List[str] = [round(x[0].real ,8 ) + round(x[0].imag ,8 ) * 1j for x in inverce_c] # Remove leading 0's while inverce_c[-1] == 0: inverce_c.pop() return inverce_c def __str__( self ): '''simple docstring''' lowercase : Optional[int] = """A = """ + """ + """.join( f"{coef}*x^{i}" for coef, i in enumerate(self.polyA[: self.len_A] ) ) lowercase : List[Any] = """B = """ + """ + """.join( f"{coef}*x^{i}" for coef, i in enumerate(self.polyB[: self.len_B] ) ) lowercase : Optional[Any] = """A*B = """ + """ + """.join( f"{coef}*x^{i}" for coef, i in enumerate(self.product ) ) return f"{a}\n{b}\n{c}" # Unit tests if __name__ == "__main__": import doctest doctest.testmod()
20
import torch from transformers import CamembertForMaskedLM, CamembertTokenizer def A ( _UpperCAmelCase : str , _UpperCAmelCase : Any , _UpperCAmelCase : List[str] , _UpperCAmelCase : Optional[int]=5 ) -> List[Any]: '''simple docstring''' # Adapted from https://github.com/pytorch/fairseq/blob/master/fairseq/models/roberta/hub_interface.py assert masked_input.count('<mask>' ) == 1 _UpperCAmelCase = torch.tensor(tokenizer.encode(_UpperCAmelCase , add_special_tokens=_UpperCAmelCase ) ).unsqueeze(0 ) # Batch size 1 _UpperCAmelCase = model(_UpperCAmelCase )[0] # The last hidden-state is the first element of the output tuple _UpperCAmelCase = (input_ids.squeeze() == tokenizer.mask_token_id).nonzero().item() _UpperCAmelCase = logits[0, masked_index, :] _UpperCAmelCase = logits.softmax(dim=0 ) _UpperCAmelCase , _UpperCAmelCase = prob.topk(k=_UpperCAmelCase , dim=0 ) _UpperCAmelCase = ' '.join( [tokenizer.convert_ids_to_tokens(indices[i].item() ) for i in range(len(_UpperCAmelCase ) )] ) _UpperCAmelCase = tokenizer.mask_token _UpperCAmelCase = [] for index, predicted_token_bpe in enumerate(topk_predicted_token_bpe.split(' ' ) ): _UpperCAmelCase = predicted_token_bpe.replace('\u2581' , ' ' ) if " {0}".format(_UpperCAmelCase ) in masked_input: topk_filled_outputs.append( ( masked_input.replace(' {0}'.format(_UpperCAmelCase ) , _UpperCAmelCase ), values[index].item(), predicted_token, ) ) else: topk_filled_outputs.append( ( masked_input.replace(_UpperCAmelCase , _UpperCAmelCase ), values[index].item(), predicted_token, ) ) return topk_filled_outputs UpperCAmelCase__ = CamembertTokenizer.from_pretrained("camembert-base") UpperCAmelCase__ = CamembertForMaskedLM.from_pretrained("camembert-base") model.eval() UpperCAmelCase__ = "Le camembert est <mask> :)" print(fill_mask(masked_input, model, tokenizer, topk=3))
339
0