code
stringlengths
86
54.5k
code_codestyle
int64
0
371
style_context
stringlengths
87
49.2k
style_context_codestyle
int64
0
349
label
int64
0
1
'''simple docstring''' import csv from collections import defaultdict from dataclasses import dataclass, field from typing import List, Optional import matplotlib.pyplot as plt import numpy as np from matplotlib.ticker import ScalarFormatter from transformers import HfArgumentParser def A__ ( UpperCAmelCase_=None , UpperCAmelCase_=None ): return field(default_factory=lambda: default , metadata=UpperCAmelCase_ ) @dataclass class lowercase__ : lowercase__ = field( metadata={"""help""": """The csv file to plot."""} , ) lowercase__ = field( default=lowercase , metadata={"""help""": """Whether to plot along batch size or sequence length. Defaults to sequence length."""} , ) lowercase__ = field( default=lowercase , metadata={"""help""": """Whether the csv file has time results or memory results. Defaults to memory results."""} , ) lowercase__ = field( default=lowercase , metadata={"""help""": """Disable logarithmic scale when plotting"""} , ) lowercase__ = field( default=lowercase , metadata={ """help""": """Whether the csv file has training results or inference results. Defaults to inference results.""" } , ) lowercase__ = field( default=lowercase , metadata={"""help""": """Filename under which the plot will be saved. If unused no plot is saved."""} , ) lowercase__ = list_field( default=lowercase , metadata={"""help""": """List of model names that are used instead of the ones in the csv file."""} ) def A__ ( UpperCAmelCase_ ): try: int(UpperCAmelCase_ ) return True except ValueError: return False def A__ ( UpperCAmelCase_ ): try: float(UpperCAmelCase_ ) return True except ValueError: return False class lowercase__ : def __init__( self : List[Any] ,lowerCamelCase__ : List[str] ): '''simple docstring''' _UpperCamelCase : Optional[Any] = args _UpperCamelCase : Optional[Any] = defaultdict(lambda: {"bsz": [], "seq_len": [], "result": {}} ) with open(self.args.csv_file ,newline='' ) as csv_file: _UpperCamelCase : List[Any] = csv.DictReader(lowerCamelCase__ ) for row in reader: _UpperCamelCase : Any = row['model'] self.result_dict[model_name]["bsz"].append(int(row['batch_size'] ) ) self.result_dict[model_name]["seq_len"].append(int(row['sequence_length'] ) ) if can_convert_to_int(row['result'] ): # value is not None _UpperCamelCase : Optional[int] = int(row['result'] ) elif can_convert_to_float(row['result'] ): # value is not None _UpperCamelCase : Dict = float(row['result'] ) def UpperCamelCase_ ( self : Optional[Any] ): '''simple docstring''' _UpperCamelCase , _UpperCamelCase : Optional[int] = plt.subplots() _UpperCamelCase : List[str] = 'Time usage' if self.args.is_time else 'Memory usage' _UpperCamelCase : List[Any] = title_str + ' for training' if self.args.is_train else title_str + ' for inference' if not self.args.no_log_scale: # set logarithm scales ax.set_xscale('log' ) ax.set_yscale('log' ) for axis in [ax.xaxis, ax.yaxis]: axis.set_major_formatter(ScalarFormatter() ) for model_name_idx, model_name in enumerate(self.result_dict.keys() ): _UpperCamelCase : Dict = sorted(set(self.result_dict[model_name]['bsz'] ) ) _UpperCamelCase : Optional[int] = sorted(set(self.result_dict[model_name]['seq_len'] ) ) _UpperCamelCase : List[str] = self.result_dict[model_name]['result'] ((_UpperCamelCase) , (_UpperCamelCase)) : Tuple = ( (batch_sizes, sequence_lengths) if self.args.plot_along_batch else (sequence_lengths, batch_sizes) ) _UpperCamelCase : Any = ( model_name if self.args.short_model_names is None else self.args.short_model_names[model_name_idx] ) for inner_loop_value in inner_loop_array: if self.args.plot_along_batch: _UpperCamelCase : Optional[Any] = np.asarray( [results[(x, inner_loop_value)] for x in x_axis_array if (x, inner_loop_value) in results] ,dtype=lowerCamelCase__ ,) else: _UpperCamelCase : str = np.asarray( [results[(inner_loop_value, x)] for x in x_axis_array if (inner_loop_value, x) in results] ,dtype=np.floataa ,) ((_UpperCamelCase) , (_UpperCamelCase)) : Tuple = ( ('batch_size', 'len') if self.args.plot_along_batch else ('in #tokens', 'bsz') ) _UpperCamelCase : Dict = np.asarray(lowerCamelCase__ ,lowerCamelCase__ )[: len(lowerCamelCase__ )] plt.scatter( lowerCamelCase__ ,lowerCamelCase__ ,label=F'{label_model_name} - {inner_loop_label}: {inner_loop_value}' ) plt.plot(lowerCamelCase__ ,lowerCamelCase__ ,'--' ) title_str += F' {label_model_name} vs.' _UpperCamelCase : Optional[Any] = title_str[:-4] _UpperCamelCase : str = 'Time in s' if self.args.is_time else 'Memory in MB' # plot plt.title(lowerCamelCase__ ) plt.xlabel(lowerCamelCase__ ) plt.ylabel(lowerCamelCase__ ) plt.legend() if self.args.figure_png_file is not None: plt.savefig(self.args.figure_png_file ) else: plt.show() def A__ ( ): _UpperCamelCase : str = HfArgumentParser(UpperCAmelCase_ ) _UpperCamelCase : Dict = parser.parse_args_into_dataclasses()[0] _UpperCamelCase : List[str] = Plot(args=UpperCAmelCase_ ) plot.plot() if __name__ == "__main__": main()
83
'''simple docstring''' from ...configuration_utils import PretrainedConfig from ...utils import logging from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices _lowerCAmelCase = logging.get_logger(__name__) _lowerCAmelCase = { '''microsoft/focalnet-tiny''': '''https://huggingface.co/microsoft/focalnet-tiny/resolve/main/config.json''', } class lowerCAmelCase_( SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ): '''simple docstring''' __lowercase : Optional[Any] = '''focalnet''' def __init__( self ,__UpperCAmelCase=224 ,__UpperCAmelCase=4 ,__UpperCAmelCase=3 ,__UpperCAmelCase=96 ,__UpperCAmelCase=False ,__UpperCAmelCase=[192, 384, 768, 768] ,__UpperCAmelCase=[2, 2, 6, 2] ,__UpperCAmelCase=[2, 2, 2, 2] ,__UpperCAmelCase=[3, 3, 3, 3] ,__UpperCAmelCase="gelu" ,__UpperCAmelCase=4.0 ,__UpperCAmelCase=0.0 ,__UpperCAmelCase=0.1 ,__UpperCAmelCase=False ,__UpperCAmelCase=1E-4 ,__UpperCAmelCase=False ,__UpperCAmelCase=False ,__UpperCAmelCase=False ,__UpperCAmelCase=0.0_2 ,__UpperCAmelCase=1E-5 ,__UpperCAmelCase=32 ,__UpperCAmelCase=None ,__UpperCAmelCase=None ,**__UpperCAmelCase ,) -> Optional[Any]: super().__init__(**__UpperCAmelCase ) lowerCAmelCase__ : Dict = image_size lowerCAmelCase__ : int = patch_size lowerCAmelCase__ : str = num_channels lowerCAmelCase__ : Dict = embed_dim lowerCAmelCase__ : List[str] = use_conv_embed lowerCAmelCase__ : List[Any] = hidden_sizes lowerCAmelCase__ : Dict = depths lowerCAmelCase__ : List[str] = focal_levels lowerCAmelCase__ : List[str] = focal_windows lowerCAmelCase__ : Dict = hidden_act lowerCAmelCase__ : Dict = mlp_ratio lowerCAmelCase__ : Tuple = hidden_dropout_prob lowerCAmelCase__ : Tuple = drop_path_rate lowerCAmelCase__ : Dict = use_layerscale lowerCAmelCase__ : Optional[Any] = layerscale_value lowerCAmelCase__ : str = use_post_layernorm lowerCAmelCase__ : Union[str, Any] = use_post_layernorm_in_modulation lowerCAmelCase__ : int = normalize_modulator lowerCAmelCase__ : Optional[Any] = initializer_range lowerCAmelCase__ : List[str] = layer_norm_eps lowerCAmelCase__ : List[Any] = encoder_stride lowerCAmelCase__ : Dict = ["""stem"""] + [F"""stage{idx}""" for idx in range(1 ,len(self.depths ) + 1 )] lowerCAmelCase__ , lowerCAmelCase__ : Any = get_aligned_output_features_output_indices( out_features=__UpperCAmelCase ,out_indices=__UpperCAmelCase ,stage_names=self.stage_names )
37
0
'''simple docstring''' from typing import Optional from urllib.parse import quote import huggingface_hub as hfh from packaging import version def __lowercase ( __lowercase , __lowercase , __lowercase = None ) -> str: '''simple docstring''' if version.parse(hfh.__version__ ).release < version.parse("0.11.0" ).release: # old versions of hfh don't url-encode the file path _A = quote(__lowercase ) return hfh.hf_hub_url(__lowercase , __lowercase , repo_type="dataset" , revision=__lowercase )
174
'''simple docstring''' import os from collections import deque import torch from torch.utils.data import Dataset class _UpperCAmelCase ( snake_case_ ): """simple docstring""" def __init__( self : Dict , __UpperCAmelCase : Union[str, Any]="" , __UpperCAmelCase : List[str]="train" ): '''simple docstring''' assert os.path.isdir(__UpperCAmelCase ) _A = [] _A = os.listdir(__UpperCAmelCase ) for story_filename in story_filenames_list: if "summary" in story_filename: continue _A = os.path.join(__UpperCAmelCase , __UpperCAmelCase ) if not os.path.isfile(__UpperCAmelCase ): continue self.documents.append(__UpperCAmelCase ) def __len__( self : str ): '''simple docstring''' return len(self.documents ) def __getitem__( self : Union[str, Any] , __UpperCAmelCase : str ): '''simple docstring''' _A = self.documents[idx] _A = document_path.split("/" )[-1] with open(__UpperCAmelCase , encoding="utf-8" ) as source: _A = source.read() _A , _A = process_story(__UpperCAmelCase ) return document_name, story_lines, summary_lines def __lowercase ( __lowercase ) -> Optional[Any]: '''simple docstring''' _A = list(filter(lambda __lowercase : len(__lowercase ) != 0 , [line.strip() for line in raw_story.split("\n" )] ) ) # for some unknown reason some lines miss a period, add it _A = [_add_missing_period(__lowercase ) for line in nonempty_lines] # gather article lines _A = [] _A = deque(__lowercase ) while True: try: _A = lines.popleft() if element.startswith("@highlight" ): break story_lines.append(__lowercase ) except IndexError: # if "@highlight" is absent from the file we pop # all elements until there is None, raising an exception. return story_lines, [] # gather summary lines _A = list(filter(lambda __lowercase : not t.startswith("@highlight" ) , __lowercase ) ) return story_lines, summary_lines def __lowercase ( __lowercase ) -> Optional[int]: '''simple docstring''' _A = [".", "!", "?", "...", "'", "`", "\"", "\u2019", "\u2019", ")"] if line.startswith("@highlight" ): return line if line[-1] in END_TOKENS: return line return line + "." def __lowercase ( __lowercase , __lowercase , __lowercase ) -> str: '''simple docstring''' if len(__lowercase ) > block_size: return sequence[:block_size] else: sequence.extend([pad_token_id] * (block_size - len(__lowercase )) ) return sequence def __lowercase ( __lowercase , __lowercase ) -> Optional[int]: '''simple docstring''' _A = torch.ones_like(__lowercase ) _A = sequence == pad_token_id _A = 0 return mask def __lowercase ( __lowercase , __lowercase , __lowercase ) -> str: '''simple docstring''' _A = [tokenizer.encode(__lowercase ) for line in story_lines] _A = [token for sentence in story_lines_token_ids for token in sentence] _A = [tokenizer.encode(__lowercase ) for line in summary_lines] _A = [token for sentence in summary_lines_token_ids for token in sentence] return story_token_ids, summary_token_ids def __lowercase ( __lowercase , __lowercase ) -> List[str]: '''simple docstring''' _A = [] for sequence in batch: _A = -1 _A = [] for s in sequence: if s == separator_token_id: sentence_num += 1 embeddings.append(sentence_num % 2 ) batch_embeddings.append(__lowercase ) return torch.tensor(__lowercase )
174
1
"""simple docstring""" # Function to print upper half of diamond (pyramid) def _snake_case ( snake_case__ : Dict ): for i in range(0 , snake_case__ ): for _ in range(0 , n - i - 1 ): # printing spaces print(' ' , end='' ) for _ in range(0 , i + 1 ): # printing stars print('* ' , end='' ) print() def _snake_case ( snake_case__ : Tuple ): for i in range(snake_case__ , 0 , -1 ): for _ in range(snake_case__ , 0 , -1 ): # printing stars print('* ' , end='' ) print() for _ in range(n - i + 1 , 0 , -1 ): # printing spaces print(' ' , end='' ) def _snake_case ( snake_case__ : Dict ): if n <= 0: print(' ... .... nothing printing :(' ) return floyd(snake_case__ ) # upper half reverse_floyd(snake_case__ ) # lower half if __name__ == "__main__": print(r'''| /\ | |- | |- |--| |\ /| |-''') print(r'''|/ \| |- |_ |_ |__| | \/ | |_''') _lowercase = 1 while K: _lowercase = int(input('''enter the number and , and see the magic : ''')) print() pretty_print(user_number) _lowercase = int(input('''press 0 to exit... and 1 to continue...''')) print('''Good Bye...''')
74
'''simple docstring''' import pickle import unittest import torch from accelerate import Accelerator from accelerate.state import AcceleratorState from accelerate.test_utils import require_cpu @require_cpu class UpperCAmelCase_ ( unittest.TestCase ): def __UpperCAmelCase ( self : str ) -> List[Any]: lowerCAmelCase = torch.nn.Linear(1_0 , 1_0 ) lowerCAmelCase = torch.optim.SGD(model.parameters() , 0.1 ) lowerCAmelCase = Accelerator() lowerCAmelCase = accelerator.prepare(UpperCAmelCase__ ) try: pickle.loads(pickle.dumps(UpperCAmelCase__ ) ) except Exception as e: self.fail(F'''Accelerated optimizer pickling failed with {e}''' ) AcceleratorState._reset_state()
4
0
"""simple docstring""" from typing import Dict, List, Optional, Union import numpy as np from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict from ...image_transforms import ( center_crop, get_resize_output_image_size, normalize, rescale, resize, to_channel_dimension_format, ) from ...image_utils import ( IMAGENET_STANDARD_MEAN, IMAGENET_STANDARD_STD, ChannelDimension, ImageInput, PILImageResampling, make_list_of_images, to_numpy_array, valid_images, ) from ...utils import TensorType, is_vision_available, logging if is_vision_available(): import PIL a : List[Any] = logging.get_logger(__name__) class __UpperCamelCase ( a__ ): lowerCamelCase : Optional[int] =["""pixel_values"""] def __init__( self , lowerCAmelCase__ = True , lowerCAmelCase__ = None , lowerCAmelCase__ = None , lowerCAmelCase__ = PILImageResampling.BILINEAR , lowerCAmelCase__ = True , lowerCAmelCase__ = 1 / 255 , lowerCAmelCase__ = True , lowerCAmelCase__ = None , lowerCAmelCase__ = None , **lowerCAmelCase__ , ) -> None: super().__init__(**lowerCAmelCase__ ) a : Dict = size if size is not None else {"shortest_edge": 384} a : Any = get_size_dict(lowerCAmelCase__ , default_to_square=lowerCAmelCase__ ) a : List[str] = do_resize a : Optional[int] = size # Default value set here for backwards compatibility where the value in config is None a : Dict = crop_pct if crop_pct is not None else 224 / 256 a : Union[str, Any] = resample a : int = do_rescale a : int = rescale_factor a : Union[str, Any] = do_normalize a : Union[str, Any] = image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN a : List[str] = image_std if image_std is not None else IMAGENET_STANDARD_STD def __a ( self , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ = PILImageResampling.BICUBIC , lowerCAmelCase__ = None , **lowerCAmelCase__ , ) -> np.ndarray: a : Dict = get_size_dict(lowerCAmelCase__ , default_to_square=lowerCAmelCase__ ) if "shortest_edge" not in size: raise ValueError(f"""Size dictionary must contain 'shortest_edge' key. Got {size.keys()}""" ) a : List[str] = size["shortest_edge"] if shortest_edge < 384: # maintain same ratio, resizing shortest edge to shortest_edge/crop_pct a : int = int(shortest_edge / crop_pct ) a : Union[str, Any] = get_resize_output_image_size(lowerCAmelCase__ , size=lowerCAmelCase__ , default_to_square=lowerCAmelCase__ ) a : Optional[int] = resize(image=lowerCAmelCase__ , size=lowerCAmelCase__ , resample=lowerCAmelCase__ , data_format=lowerCAmelCase__ , **lowerCAmelCase__ ) # then crop to (shortest_edge, shortest_edge) return center_crop(image=lowerCAmelCase__ , size=(shortest_edge, shortest_edge) , data_format=lowerCAmelCase__ , **lowerCAmelCase__ ) else: # warping (no cropping) when evaluated at 384 or larger return resize( lowerCAmelCase__ , size=(shortest_edge, shortest_edge) , resample=lowerCAmelCase__ , data_format=lowerCAmelCase__ , **lowerCAmelCase__ ) def __a ( self , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ = None , **lowerCAmelCase__ , ) -> List[Any]: return rescale(lowerCAmelCase__ , scale=lowerCAmelCase__ , data_format=lowerCAmelCase__ , **lowerCAmelCase__ ) def __a ( self , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ = None , **lowerCAmelCase__ , ) -> np.ndarray: return normalize(lowerCAmelCase__ , mean=lowerCAmelCase__ , std=lowerCAmelCase__ , data_format=lowerCAmelCase__ , **lowerCAmelCase__ ) def __a ( self , lowerCAmelCase__ , lowerCAmelCase__ = None , lowerCAmelCase__ = None , lowerCAmelCase__ = None , lowerCAmelCase__ = None , lowerCAmelCase__ = None , lowerCAmelCase__ = None , lowerCAmelCase__ = None , lowerCAmelCase__ = None , lowerCAmelCase__ = None , lowerCAmelCase__ = None , lowerCAmelCase__ = ChannelDimension.FIRST , **lowerCAmelCase__ , ) -> PIL.Image.Image: a : Optional[Any] = do_resize if do_resize is not None else self.do_resize a : Dict = crop_pct if crop_pct is not None else self.crop_pct a : List[Any] = resample if resample is not None else self.resample a : Union[str, Any] = do_rescale if do_rescale is not None else self.do_rescale a : int = rescale_factor if rescale_factor is not None else self.rescale_factor a : Optional[int] = do_normalize if do_normalize is not None else self.do_normalize a : Any = image_mean if image_mean is not None else self.image_mean a : Any = image_std if image_std is not None else self.image_std a : Tuple = size if size is not None else self.size a : List[Any] = get_size_dict(lowerCAmelCase__ , default_to_square=lowerCAmelCase__ ) a : int = make_list_of_images(lowerCAmelCase__ ) if not valid_images(lowerCAmelCase__ ): raise ValueError( "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, " "torch.Tensor, tf.Tensor or jax.ndarray." ) if do_resize and size is None or resample is None: raise ValueError("Size and resample must be specified if do_resize is True." ) if do_resize and size["shortest_edge"] < 384 and crop_pct is None: raise ValueError("crop_pct must be specified if size < 384." ) if do_rescale and rescale_factor is None: raise ValueError("Rescale factor must be specified if do_rescale is True." ) if do_normalize and (image_mean is None or image_std is None): raise ValueError("Image mean and std must be specified if do_normalize is True." ) # All transformations expect numpy arrays. a : Any = [to_numpy_array(lowerCAmelCase__ ) for image in images] if do_resize: a : Any = [self.resize(image=lowerCAmelCase__ , size=lowerCAmelCase__ , crop_pct=lowerCAmelCase__ , resample=lowerCAmelCase__ ) for image in images] if do_rescale: a : List[Any] = [self.rescale(image=lowerCAmelCase__ , scale=lowerCAmelCase__ ) for image in images] if do_normalize: a : Any = [self.normalize(image=lowerCAmelCase__ , mean=lowerCAmelCase__ , std=lowerCAmelCase__ ) for image in images] a : Tuple = [to_channel_dimension_format(lowerCAmelCase__ , lowerCAmelCase__ ) for image in images] a : Optional[int] = {"pixel_values": images} return BatchFeature(data=lowerCAmelCase__ , tensor_type=lowerCAmelCase__ )
370
"""simple docstring""" import math def _SCREAMING_SNAKE_CASE ( _lowercase : int = 100 ) ->int: '''simple docstring''' a : Dict = sum(i * i for i in range(1 , n + 1 ) ) a : Tuple = int(math.pow(sum(range(1 , n + 1 ) ) , 2 ) ) return square_of_sum - sum_of_squares if __name__ == "__main__": print(F'''{solution() = }''')
79
0
def SCREAMING_SNAKE_CASE_ ( __A : list[int] , __A : str ) -> list[int]: """simple docstring""" a_ : Any = int(__A ) # Initialize Result a_ : Tuple = [] # Traverse through all denomination for denomination in reversed(__A ): # Find denominations while int(__A ) >= int(__A ): total_value -= int(__A ) answer.append(__A ) # Append the "answers" array return answer # Driver Code if __name__ == "__main__": UpperCAmelCase_ : Union[str, Any] = [] UpperCAmelCase_ : Union[str, Any] = '0' if ( input('Do you want to enter your denominations ? (yY/n): ').strip().lower() == "y" ): UpperCAmelCase_ : List[Any] = int(input('Enter the number of denominations you want to add: ').strip()) for i in range(0, n): denominations.append(int(input(F'Denomination {i}: ').strip())) UpperCAmelCase_ : str = input('Enter the change you want to make in Indian Currency: ').strip() else: # All denominations of Indian Currency if user does not enter UpperCAmelCase_ : List[Any] = [1, 2, 5, 10, 20, 50, 100, 500, 2000] UpperCAmelCase_ : str = input('Enter the change you want to make: ').strip() if int(value) == 0 or int(value) < 0: print('The total value cannot be zero or negative.') else: print(F'Following is minimal change for {value}: ') UpperCAmelCase_ : Optional[Any] = find_minimum_change(denominations, value) # Print result for i in range(len(answer)): print(answer[i], end=' ')
32
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 SCREAMING_SNAKE_CASE__ : def __init__( self : List[str] , SCREAMING_SNAKE_CASE__ : Dict , SCREAMING_SNAKE_CASE__ : Tuple=1_3 , SCREAMING_SNAKE_CASE__ : str=7 , SCREAMING_SNAKE_CASE__ : List[str]=True , SCREAMING_SNAKE_CASE__ : Optional[Any]=True , SCREAMING_SNAKE_CASE__ : Union[str, Any]=True , SCREAMING_SNAKE_CASE__ : Optional[Any]=9_9 , SCREAMING_SNAKE_CASE__ : Optional[Any]=3_2 , SCREAMING_SNAKE_CASE__ : List[str]=5 , SCREAMING_SNAKE_CASE__ : List[Any]=4 , SCREAMING_SNAKE_CASE__ : Tuple=3_7 , SCREAMING_SNAKE_CASE__ : Any="gelu" , SCREAMING_SNAKE_CASE__ : Dict=0.1 , SCREAMING_SNAKE_CASE__ : Dict=0.1 , SCREAMING_SNAKE_CASE__ : int=5_1_2 , SCREAMING_SNAKE_CASE__ : int=1_6 , SCREAMING_SNAKE_CASE__ : Optional[int]=2 , SCREAMING_SNAKE_CASE__ : Any=0.02 , SCREAMING_SNAKE_CASE__ : Union[str, Any]=3 , SCREAMING_SNAKE_CASE__ : Optional[Any]=4 , SCREAMING_SNAKE_CASE__ : Optional[int]=None , ) -> Any: a_ : Tuple = parent a_ : int = batch_size a_ : Tuple = seq_length a_ : List[Any] = is_training a_ : List[str] = use_token_type_ids a_ : Dict = use_labels a_ : Any = vocab_size a_ : List[str] = hidden_size a_ : Tuple = num_hidden_layers a_ : List[Any] = num_attention_heads a_ : Dict = intermediate_size a_ : Any = hidden_act a_ : List[str] = hidden_dropout_prob a_ : Tuple = attention_probs_dropout_prob a_ : Optional[Any] = max_position_embeddings a_ : List[Any] = type_vocab_size a_ : int = type_sequence_label_size a_ : List[Any] = initializer_range a_ : List[str] = num_labels a_ : Union[str, Any] = num_choices a_ : str = scope a_ : Tuple = self.vocab_size - 1 def SCREAMING_SNAKE_CASE ( self : Union[str, Any] ) -> Any: a_ : Optional[int] = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) a_ : Any = None if self.use_token_type_ids: a_ : Tuple = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) a_ : List[Any] = None a_ : Union[str, Any] = None a_ : List[Any] = None if self.use_labels: a_ : Tuple = ids_tensor([self.batch_size] , self.type_sequence_label_size ) a_ : Any = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) a_ : List[Any] = ids_tensor([self.batch_size] , self.num_choices ) a_ : Union[str, Any] = 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 , ) a_ : List[str] = 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 SCREAMING_SNAKE_CASE ( self : List[str] , SCREAMING_SNAKE_CASE__ : Any , SCREAMING_SNAKE_CASE__ : Union[str, Any] , SCREAMING_SNAKE_CASE__ : Any , SCREAMING_SNAKE_CASE__ : List[str] , *SCREAMING_SNAKE_CASE__ : Tuple ) -> Union[str, Any]: a_ : Dict = OpenAIGPTModel(config=SCREAMING_SNAKE_CASE__ ) model.to(SCREAMING_SNAKE_CASE__ ) model.eval() a_ : str = model(SCREAMING_SNAKE_CASE__ , token_type_ids=SCREAMING_SNAKE_CASE__ , head_mask=SCREAMING_SNAKE_CASE__ ) a_ : Dict = model(SCREAMING_SNAKE_CASE__ , token_type_ids=SCREAMING_SNAKE_CASE__ ) a_ : Dict = model(SCREAMING_SNAKE_CASE__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def SCREAMING_SNAKE_CASE ( self : Optional[int] , SCREAMING_SNAKE_CASE__ : List[str] , SCREAMING_SNAKE_CASE__ : Tuple , SCREAMING_SNAKE_CASE__ : Tuple , SCREAMING_SNAKE_CASE__ : Union[str, Any] , *SCREAMING_SNAKE_CASE__ : Optional[int] ) -> Any: a_ : str = OpenAIGPTLMHeadModel(SCREAMING_SNAKE_CASE__ ) model.to(SCREAMING_SNAKE_CASE__ ) model.eval() a_ : Optional[int] = model(SCREAMING_SNAKE_CASE__ , token_type_ids=SCREAMING_SNAKE_CASE__ , labels=SCREAMING_SNAKE_CASE__ ) self.parent.assertEqual(result.loss.shape , () ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def SCREAMING_SNAKE_CASE ( self : Optional[Any] , SCREAMING_SNAKE_CASE__ : Optional[Any] , SCREAMING_SNAKE_CASE__ : int , SCREAMING_SNAKE_CASE__ : Optional[int] , SCREAMING_SNAKE_CASE__ : Optional[Any] , *SCREAMING_SNAKE_CASE__ : Union[str, Any] ) -> Dict: a_ : int = OpenAIGPTDoubleHeadsModel(SCREAMING_SNAKE_CASE__ ) model.to(SCREAMING_SNAKE_CASE__ ) model.eval() a_ : str = model(SCREAMING_SNAKE_CASE__ , token_type_ids=SCREAMING_SNAKE_CASE__ , labels=SCREAMING_SNAKE_CASE__ ) self.parent.assertEqual(result.loss.shape , () ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def SCREAMING_SNAKE_CASE ( self : Tuple , SCREAMING_SNAKE_CASE__ : Dict , SCREAMING_SNAKE_CASE__ : Dict , SCREAMING_SNAKE_CASE__ : List[Any] , SCREAMING_SNAKE_CASE__ : Union[str, Any] , *SCREAMING_SNAKE_CASE__ : str ) -> List[str]: a_ : Any = self.num_labels a_ : Dict = OpenAIGPTForSequenceClassification(SCREAMING_SNAKE_CASE__ ) model.to(SCREAMING_SNAKE_CASE__ ) model.eval() a_ : Dict = ids_tensor([self.batch_size] , self.type_sequence_label_size ) a_ : Any = model(SCREAMING_SNAKE_CASE__ , token_type_ids=SCREAMING_SNAKE_CASE__ , labels=SCREAMING_SNAKE_CASE__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def SCREAMING_SNAKE_CASE ( self : Union[str, Any] ) -> Tuple: a_ : Optional[Any] = self.prepare_config_and_inputs() ( ( a_ ) , ( a_ ) , ( a_ ) , ( a_ ) , ( a_ ) , ( a_ ) , ( a_ ) , ) : Optional[Any] = config_and_inputs a_ : Optional[int] = { 'input_ids': input_ids, 'token_type_ids': token_type_ids, 'head_mask': head_mask, } return config, inputs_dict @require_torch class SCREAMING_SNAKE_CASE__ ( lowercase__ , lowercase__ , lowercase__ , unittest.TestCase ): snake_case__ : Tuple = ( (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification) if is_torch_available() else () ) snake_case__ : List[str] = ( (OpenAIGPTLMHeadModel,) if is_torch_available() else () ) # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly snake_case__ : Dict = ( { '''feature-extraction''': OpenAIGPTModel, '''text-classification''': OpenAIGPTForSequenceClassification, '''text-generation''': OpenAIGPTLMHeadModel, '''zero-shot''': OpenAIGPTForSequenceClassification, } if is_torch_available() else {} ) def SCREAMING_SNAKE_CASE ( self : List[str] , SCREAMING_SNAKE_CASE__ : Tuple , SCREAMING_SNAKE_CASE__ : Optional[Any] , SCREAMING_SNAKE_CASE__ : Tuple , SCREAMING_SNAKE_CASE__ : Dict , SCREAMING_SNAKE_CASE__ : List[str] ) -> Dict: 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 SCREAMING_SNAKE_CASE ( self : int , SCREAMING_SNAKE_CASE__ : Dict , SCREAMING_SNAKE_CASE__ : Dict , SCREAMING_SNAKE_CASE__ : Any=False ) -> List[str]: a_ : str = super()._prepare_for_class(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , return_labels=SCREAMING_SNAKE_CASE__ ) if return_labels: if model_class.__name__ == "OpenAIGPTDoubleHeadsModel": a_ : Optional[Any] = torch.zeros( (self.model_tester.batch_size, self.model_tester.num_choices, self.model_tester.seq_length) , dtype=torch.long , device=SCREAMING_SNAKE_CASE__ , ) a_ : str = inputs_dict['labels'] a_ : Optional[int] = inputs_dict['labels'] a_ : Optional[int] = torch.zeros( (self.model_tester.batch_size, self.model_tester.num_choices) , dtype=torch.long , device=SCREAMING_SNAKE_CASE__ , ) a_ : Union[str, Any] = torch.zeros( self.model_tester.batch_size , dtype=torch.long , device=SCREAMING_SNAKE_CASE__ ) return inputs_dict def SCREAMING_SNAKE_CASE ( self : str ) -> List[Any]: a_ : str = OpenAIGPTModelTester(self ) a_ : int = ConfigTester(self , config_class=SCREAMING_SNAKE_CASE__ , n_embd=3_7 ) def SCREAMING_SNAKE_CASE ( self : Tuple ) -> Tuple: self.config_tester.run_common_tests() def SCREAMING_SNAKE_CASE ( self : List[Any] ) -> Tuple: a_ : Dict = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_openai_gpt_model(*SCREAMING_SNAKE_CASE__ ) def SCREAMING_SNAKE_CASE ( self : Optional[int] ) -> Tuple: a_ : Any = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_lm_head_model(*SCREAMING_SNAKE_CASE__ ) def SCREAMING_SNAKE_CASE ( self : Any ) -> Optional[Any]: a_ : Optional[int] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_double_lm_head_model(*SCREAMING_SNAKE_CASE__ ) def SCREAMING_SNAKE_CASE ( self : Optional[Any] ) -> Optional[Any]: a_ : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*SCREAMING_SNAKE_CASE__ ) @slow def SCREAMING_SNAKE_CASE ( self : List[str] ) -> str: for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: a_ : str = OpenAIGPTModel.from_pretrained(SCREAMING_SNAKE_CASE__ ) self.assertIsNotNone(SCREAMING_SNAKE_CASE__ ) @require_torch class SCREAMING_SNAKE_CASE__ ( unittest.TestCase ): @slow def SCREAMING_SNAKE_CASE ( self : Dict ) -> int: a_ : Dict = OpenAIGPTLMHeadModel.from_pretrained('openai-gpt' ) model.to(SCREAMING_SNAKE_CASE__ ) a_ : List[Any] = torch.tensor([[4_8_1, 4_7_3_5, 5_4_4]] , dtype=torch.long , device=SCREAMING_SNAKE_CASE__ ) # the president is a_ : Tuple = [ 4_8_1, 4_7_3_5, 5_4_4, 2_4_6, 9_6_3, 8_7_0, 7_6_2, 2_3_9, 2_4_4, 4_0_4_7_7, 2_4_4, 2_4_9, 7_1_9, 8_8_1, 4_8_7, 5_4_4, 2_4_0, 2_4_4, 6_0_3, 4_8_1, ] # the president is a very good man. " \n " i\'m sure he is, " said the a_ : Dict = model.generate(SCREAMING_SNAKE_CASE__ , do_sample=SCREAMING_SNAKE_CASE__ ) self.assertListEqual(output_ids[0].tolist() , SCREAMING_SNAKE_CASE__ )
32
1
'''simple docstring''' def UpperCAmelCase ( lowerCamelCase_ :int ): '''simple docstring''' snake_case_ : List[Any] = generate_pascal_triangle(lowerCamelCase_ ) for row_idx in range(lowerCamelCase_ ): # Print left spaces for _ in range(num_rows - row_idx - 1 ): print(end=""" """ ) # Print row values for col_idx in range(row_idx + 1 ): if col_idx != row_idx: print(triangle[row_idx][col_idx] , end=""" """ ) else: print(triangle[row_idx][col_idx] , end="""""" ) print() def UpperCAmelCase ( lowerCamelCase_ :int ): '''simple docstring''' if not isinstance(lowerCamelCase_ , lowerCamelCase_ ): raise TypeError("""The input value of 'num_rows' should be 'int'""" ) if num_rows == 0: return [] elif num_rows < 0: raise ValueError( """The input value of 'num_rows' should be greater than or equal to 0""" ) snake_case_ : list[list[int]] = [] for current_row_idx in range(lowerCamelCase_ ): snake_case_ : List[str] = populate_current_row(lowerCamelCase_ , lowerCamelCase_ ) triangle.append(lowerCamelCase_ ) return triangle def UpperCAmelCase ( lowerCamelCase_ :list[list[int]] , lowerCamelCase_ :int ): '''simple docstring''' snake_case_ : Union[str, Any] = [-1] * (current_row_idx + 1) # first and last elements of current row are equal to 1 snake_case_ : Optional[Any] = 1, 1 for current_col_idx in range(1 , lowerCamelCase_ ): calculate_current_element( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) return current_row def UpperCAmelCase ( lowerCamelCase_ :list[list[int]] , lowerCamelCase_ :list[int] , lowerCamelCase_ :int , lowerCamelCase_ :int , ): '''simple docstring''' snake_case_ : Union[str, Any] = triangle[current_row_idx - 1][current_col_idx - 1] snake_case_ : List[Any] = triangle[current_row_idx - 1][current_col_idx] snake_case_ : Optional[int] = above_to_left_elt + above_to_right_elt def UpperCAmelCase ( lowerCamelCase_ :int ): '''simple docstring''' if not isinstance(lowerCamelCase_ , lowerCamelCase_ ): raise TypeError("""The input value of 'num_rows' should be 'int'""" ) if num_rows == 0: return [] elif num_rows < 0: raise ValueError( """The input value of 'num_rows' should be greater than or equal to 0""" ) snake_case_ : list[list[int]] = [[1]] for row_index in range(1 , lowerCamelCase_ ): snake_case_ : Optional[Any] = [0] + result[-1] + [0] snake_case_ : Dict = row_index + 1 # Calculate the number of distinct elements in a row snake_case_ : Any = sum(divmod(lowerCamelCase_ , 2 ) ) snake_case_ : Tuple = [ temp_row[i - 1] + temp_row[i] for i in range(1 , distinct_elements + 1 ) ] snake_case_ : Optional[int] = row_first_half[: (row_index + 1) // 2] row_second_half.reverse() snake_case_ : str = row_first_half + row_second_half result.append(lowerCamelCase_ ) return result def UpperCAmelCase ( ): '''simple docstring''' from collections.abc import Callable from timeit import timeit def benchmark_a_function(lowerCamelCase_ :Callable , lowerCamelCase_ :int ) -> None: snake_case_ : Dict = F'''{func.__name__}({value})''' snake_case_ : Dict = timeit(F'''__main__.{call}''' , setup="""import __main__""" ) # print(f"{call:38} = {func(value)} -- {timing:.4f} seconds") print(F'''{call:38} -- {timing:.4f} seconds''' ) for value in range(15 ): # (1, 7, 14): for func in (generate_pascal_triangle, generate_pascal_triangle_optimized): benchmark_a_function(lowerCamelCase_ , lowerCamelCase_ ) print() if __name__ == "__main__": import doctest doctest.testmod() benchmark()
362
'''simple docstring''' def UpperCAmelCase ( lowerCamelCase_ :list ): '''simple docstring''' if len(lowerCamelCase_ ) <= 1: return lst snake_case_ : Union[str, Any] = 1 while i < len(lowerCamelCase_ ): if lst[i - 1] <= lst[i]: i += 1 else: snake_case_ , snake_case_ : Union[str, Any] = lst[i], lst[i - 1] i -= 1 if i == 0: snake_case_ : int = 1 return lst if __name__ == "__main__": __A : Optional[int] = input('Enter numbers separated by a comma:\n').strip() __A : int = [int(item) for item in user_input.split(',')] print(gnome_sort(unsorted))
8
0
'''simple docstring''' import inspect import re from transformers.utils import direct_transformers_import # All paths are set with the intent you should run this script from the root of the repo with the command # python utils/check_config_docstrings.py UpperCAmelCase_ = '''src/transformers''' # This is to make sure the transformers module imported is the one in the repo. UpperCAmelCase_ = direct_transformers_import(PATH_TO_TRANSFORMERS) UpperCAmelCase_ = transformers.models.auto.configuration_auto.CONFIG_MAPPING # Regex pattern used to find the checkpoint mentioned in the docstring of `config_class`. # For example, `[bert-base-uncased](https://huggingface.co/bert-base-uncased)` UpperCAmelCase_ = re.compile(r'\[(.+?)\]\((https://huggingface\.co/.+?)\)') UpperCAmelCase_ = { '''DecisionTransformerConfig''', '''EncoderDecoderConfig''', '''MusicgenConfig''', '''RagConfig''', '''SpeechEncoderDecoderConfig''', '''TimmBackboneConfig''', '''VisionEncoderDecoderConfig''', '''VisionTextDualEncoderConfig''', '''LlamaConfig''', } def _UpperCamelCase ( SCREAMING_SNAKE_CASE__ : Union[str, Any] ): '''simple docstring''' UpperCAmelCase__ = None # source code of `config_class` UpperCAmelCase__ = inspect.getsource(SCREAMING_SNAKE_CASE__ ) UpperCAmelCase__ = _re_checkpoint.findall(SCREAMING_SNAKE_CASE__ ) # Each `checkpoint` is a tuple of a checkpoint name and a checkpoint link. # For example, `('bert-base-uncased', 'https://huggingface.co/bert-base-uncased')` for ckpt_name, ckpt_link in checkpoints: # allow the link to end with `/` if ckpt_link.endswith("""/""" ): UpperCAmelCase__ = ckpt_link[:-1] # verify the checkpoint name corresponds to the checkpoint link UpperCAmelCase__ = F'''https://huggingface.co/{ckpt_name}''' if ckpt_link == ckpt_link_from_name: UpperCAmelCase__ = ckpt_name break return checkpoint def _UpperCamelCase ( ): '''simple docstring''' UpperCAmelCase__ = [] for config_class in list(CONFIG_MAPPING.values() ): # Skip deprecated models if "models.deprecated" in config_class.__module__: continue UpperCAmelCase__ = get_checkpoint_from_config_class(SCREAMING_SNAKE_CASE__ ) UpperCAmelCase__ = config_class.__name__ if checkpoint is None and name not in CONFIG_CLASSES_TO_IGNORE_FOR_DOCSTRING_CHECKPOINT_CHECK: configs_without_checkpoint.append(SCREAMING_SNAKE_CASE__ ) if len(SCREAMING_SNAKE_CASE__ ) > 0: UpperCAmelCase__ = '\n'.join(sorted(SCREAMING_SNAKE_CASE__ ) ) raise ValueError(F'''The following configurations don\'t contain any valid checkpoint:\n{message}''' ) if __name__ == "__main__": check_config_docstrings_have_checkpoints()
346
from __future__ import annotations def _SCREAMING_SNAKE_CASE ( a , a , a ) -> float: if days_between_payments <= 0: raise ValueError('days_between_payments must be > 0' ) if daily_interest_rate < 0: raise ValueError('daily_interest_rate must be >= 0' ) if principal <= 0: raise ValueError('principal must be > 0' ) return principal * daily_interest_rate * days_between_payments def _SCREAMING_SNAKE_CASE ( a , a , a , ) -> float: if number_of_compounding_periods <= 0: raise ValueError('number_of_compounding_periods must be > 0' ) if nominal_annual_interest_rate_percentage < 0: raise ValueError('nominal_annual_interest_rate_percentage must be >= 0' ) if principal <= 0: raise ValueError('principal must be > 0' ) return principal * ( (1 + nominal_annual_interest_rate_percentage) ** number_of_compounding_periods - 1 ) def _SCREAMING_SNAKE_CASE ( a , a , a , ) -> float: if number_of_years <= 0: raise ValueError('number_of_years must be > 0' ) if nominal_annual_percentage_rate < 0: raise ValueError('nominal_annual_percentage_rate must be >= 0' ) if principal <= 0: raise ValueError('principal must be > 0' ) return compound_interest( a , nominal_annual_percentage_rate / 3_65 , number_of_years * 3_65 ) if __name__ == "__main__": import doctest doctest.testmod()
280
0
import copy from dataclasses import dataclass, field from typing import ClassVar, Dict from ..features import Audio, ClassLabel, Features from .base import TaskTemplate @dataclass(frozen=__lowercase ) class lowerCAmelCase__ ( __lowercase ): a__ : str = field(default="""audio-classification""" , metadata={"""include_in_asdict_even_if_is_default""": True} ) a__ : ClassVar[Features] = Features({"""audio""": Audio()} ) a__ : ClassVar[Features] = Features({"""labels""": ClassLabel} ) a__ : str = "audio" a__ : str = "labels" def __A ( self : List[Any] , SCREAMING_SNAKE_CASE__ : Optional[Any] ) -> Optional[Any]: if self.label_column not in features: raise ValueError(f'''Column {self.label_column} is not present in features.''' ) if not isinstance(features[self.label_column] , SCREAMING_SNAKE_CASE__ ): raise ValueError(f'''Column {self.label_column} is not a ClassLabel.''' ) __lowerCamelCase = copy.deepcopy(self ) __lowerCamelCase = self.label_schema.copy() __lowerCamelCase = features[self.label_column] __lowerCamelCase = label_schema return task_template @property def __A ( self : Union[str, Any] ) -> Dict[str, str]: return { self.audio_column: "audio", self.label_column: "labels", }
339
from __future__ import annotations def __magic_name__ ( __lowerCAmelCase : list[int] ) -> bool: return len(set(__lowerCAmelCase ) ) == len(__lowerCAmelCase ) if __name__ == "__main__": import doctest doctest.testmod()
339
1
'''simple docstring''' import warnings from ...utils import logging from .image_processing_clip import CLIPImageProcessor __a = logging.get_logger(__name__) class UpperCAmelCase_ ( _a ): """simple docstring""" def __init__( self : Tuple , *snake_case_ : Union[str, Any] , **snake_case_ : Any ): warnings.warn( """The class CLIPFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please""" """ use CLIPImageProcessor instead.""" , snake_case_ , ) super().__init__(*snake_case_ , **snake_case_ )
35
'''simple docstring''' from PIL import Image def __snake_case( _lowerCAmelCase , _lowerCAmelCase ) -> Image: def brightness(_lowerCAmelCase ) -> float: return 128 + level + (c - 128) if not -255.0 <= level <= 255.0: raise ValueError("""level must be between -255.0 (black) and 255.0 (white)""" ) return img.point(_lowerCAmelCase ) if __name__ == "__main__": # Load image with Image.open("image_data/lena.jpg") as img: # Change brightness to 100 __a = change_brightness(img, 100) brigt_img.save("image_data/lena_brightness.png", format="png")
35
1
"""simple docstring""" import os from typing import List, Optional, Union from ...image_processing_utils import BatchFeature from ...image_utils import ImageInput from ...processing_utils import ProcessorMixin from ...tokenization_utils_base import PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy from ...utils import TensorType from ..auto import AutoTokenizer class snake_case__ ( snake_case_ ): _snake_case : Optional[int] = ["""image_processor""", """tokenizer"""] _snake_case : Dict = """BlipImageProcessor""" _snake_case : Any = """AutoTokenizer""" def __init__( self , lowerCamelCase , lowerCamelCase , lowerCamelCase ): super().__init__(lowerCamelCase , lowerCamelCase ) # add QFormer tokenizer __a = qformer_tokenizer def __call__( self , lowerCamelCase = None , lowerCamelCase = None , lowerCamelCase = True , lowerCamelCase = False , lowerCamelCase = None , lowerCamelCase = None , lowerCamelCase = 0 , lowerCamelCase = None , lowerCamelCase = None , lowerCamelCase = False , lowerCamelCase = False , lowerCamelCase = False , lowerCamelCase = False , lowerCamelCase = False , lowerCamelCase = True , lowerCamelCase = None , **lowerCamelCase , ): if images is None and text is None: raise ValueError("You have to specify at least images or text." ) __a = BatchFeature() if text is not None: __a = self.tokenizer( text=lowerCamelCase , add_special_tokens=lowerCamelCase , padding=lowerCamelCase , truncation=lowerCamelCase , max_length=lowerCamelCase , stride=lowerCamelCase , pad_to_multiple_of=lowerCamelCase , return_attention_mask=lowerCamelCase , return_overflowing_tokens=lowerCamelCase , return_special_tokens_mask=lowerCamelCase , return_offsets_mapping=lowerCamelCase , return_token_type_ids=lowerCamelCase , return_length=lowerCamelCase , verbose=lowerCamelCase , return_tensors=lowerCamelCase , **lowerCamelCase , ) encoding.update(lowerCamelCase ) __a = self.qformer_tokenizer( text=lowerCamelCase , add_special_tokens=lowerCamelCase , padding=lowerCamelCase , truncation=lowerCamelCase , max_length=lowerCamelCase , stride=lowerCamelCase , pad_to_multiple_of=lowerCamelCase , return_attention_mask=lowerCamelCase , return_overflowing_tokens=lowerCamelCase , return_special_tokens_mask=lowerCamelCase , return_offsets_mapping=lowerCamelCase , return_token_type_ids=lowerCamelCase , return_length=lowerCamelCase , verbose=lowerCamelCase , return_tensors=lowerCamelCase , **lowerCamelCase , ) __a = qformer_text_encoding.pop("input_ids" ) __a = qformer_text_encoding.pop("attention_mask" ) if images is not None: __a = self.image_processor(lowerCamelCase , return_tensors=lowerCamelCase ) encoding.update(lowerCamelCase ) return encoding def a__ ( self , *lowerCamelCase , **lowerCamelCase ): return self.tokenizer.batch_decode(*lowerCamelCase , **lowerCamelCase ) def a__ ( self , *lowerCamelCase , **lowerCamelCase ): return self.tokenizer.decode(*lowerCamelCase , **lowerCamelCase ) @property # Copied from transformers.models.blip.processing_blip.BlipProcessor.model_input_names def a__ ( self ): __a = self.tokenizer.model_input_names __a = self.image_processor.model_input_names return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names ) ) def a__ ( self , lowerCamelCase , **lowerCamelCase ): if os.path.isfile(lowerCamelCase ): raise ValueError(F"Provided path ({save_directory}) should be a directory, not a file" ) os.makedirs(lowerCamelCase , exist_ok=lowerCamelCase ) __a = os.path.join(lowerCamelCase , "qformer_tokenizer" ) self.qformer_tokenizer.save_pretrained(lowerCamelCase ) return super().save_pretrained(lowerCamelCase , **lowerCamelCase ) @classmethod def a__ ( cls , lowerCamelCase , **lowerCamelCase ): __a = AutoTokenizer.from_pretrained(lowerCamelCase , subfolder="qformer_tokenizer" ) __a = cls._get_arguments_from_pretrained(lowerCamelCase , **lowerCamelCase ) args.append(lowerCamelCase ) return cls(*lowerCamelCase )
268
"""simple docstring""" from typing import List, Optional, Tuple, Union import torch from ...models import UNetaDModel from ...schedulers import KarrasVeScheduler from ...utils import randn_tensor from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput class snake_case__ ( snake_case_ ): _snake_case : UNetaDModel _snake_case : KarrasVeScheduler def __init__( self , lowerCamelCase , lowerCamelCase ): super().__init__() self.register_modules(unet=lowerCamelCase , scheduler=lowerCamelCase ) @torch.no_grad() def __call__( self , lowerCamelCase = 1 , lowerCamelCase = 50 , lowerCamelCase = None , lowerCamelCase = "pil" , lowerCamelCase = True , **lowerCamelCase , ): __a = self.unet.config.sample_size __a = (batch_size, 3, img_size, img_size) __a = self.unet # sample x_0 ~ N(0, sigma_0^2 * I) __a = randn_tensor(lowerCamelCase , generator=lowerCamelCase , device=self.device ) * self.scheduler.init_noise_sigma self.scheduler.set_timesteps(lowerCamelCase ) for t in self.progress_bar(self.scheduler.timesteps ): # here sigma_t == t_i from the paper __a = self.scheduler.schedule[t] __a = self.scheduler.schedule[t - 1] if t > 0 else 0 # 1. Select temporarily increased noise level sigma_hat # 2. Add new noise to move from sample_i to sample_hat __a , __a = self.scheduler.add_noise_to_input(lowerCamelCase , lowerCamelCase , generator=lowerCamelCase ) # 3. Predict the noise residual given the noise magnitude `sigma_hat` # The model inputs and output are adjusted by following eq. (213) in [1]. __a = (sigma_hat / 2) * model((sample_hat + 1) / 2 , sigma_hat / 2 ).sample # 4. Evaluate dx/dt at sigma_hat # 5. Take Euler step from sigma to sigma_prev __a = self.scheduler.step(lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase ) if sigma_prev != 0: # 6. Apply 2nd order correction # The model inputs and output are adjusted by following eq. (213) in [1]. __a = (sigma_prev / 2) * model((step_output.prev_sample + 1) / 2 , sigma_prev / 2 ).sample __a = self.scheduler.step_correct( lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , step_output.prev_sample , step_output["derivative"] , ) __a = step_output.prev_sample __a = (sample / 2 + 0.5).clamp(0 , 1 ) __a = sample.cpu().permute(0 , 2 , 3 , 1 ).numpy() if output_type == "pil": __a = self.numpy_to_pil(lowerCamelCase ) if not return_dict: return (image,) return ImagePipelineOutput(images=lowerCamelCase )
268
1
import argparse import json from pathlib import Path import requests import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import YolosConfig, YolosForObjectDetection, YolosImageProcessor from transformers.utils import logging logging.set_verbosity_info() lowerCAmelCase = logging.get_logger(__name__) def _a ( SCREAMING_SNAKE_CASE ): """simple docstring""" lowercase__ = YolosConfig() # size of the architecture if "yolos_ti" in yolos_name: lowercase__ = 1_92 lowercase__ = 7_68 lowercase__ = 12 lowercase__ = 3 lowercase__ = [8_00, 13_33] lowercase__ = False elif yolos_name == "yolos_s_dWr": lowercase__ = 3_30 lowercase__ = 14 lowercase__ = 6 lowercase__ = 13_20 elif "yolos_s" in yolos_name: lowercase__ = 3_84 lowercase__ = 15_36 lowercase__ = 12 lowercase__ = 6 elif "yolos_b" in yolos_name: lowercase__ = [8_00, 13_44] lowercase__ = 91 lowercase__ = '''huggingface/label-files''' lowercase__ = '''coco-detection-id2label.json''' lowercase__ = json.load(open(hf_hub_download(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , repo_type='''dataset''' ) , '''r''' ) ) lowercase__ = {int(SCREAMING_SNAKE_CASE ): v for k, v in idalabel.items()} lowercase__ = idalabel lowercase__ = {v: k for k, v in idalabel.items()} return config def _a ( SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = False ): """simple docstring""" for i in range(config.num_hidden_layers ): # read in weights + bias of input projection layer (in timm, this is a single matrix + bias) lowercase__ = state_dict.pop(f'blocks.{i}.attn.qkv.weight' ) lowercase__ = state_dict.pop(f'blocks.{i}.attn.qkv.bias' ) # next, add query, keys and values (in that order) to the state dict lowercase__ = in_proj_weight[: config.hidden_size, :] lowercase__ = in_proj_bias[: config.hidden_size] lowercase__ = in_proj_weight[ config.hidden_size : config.hidden_size * 2, : ] lowercase__ = in_proj_bias[ config.hidden_size : config.hidden_size * 2 ] lowercase__ = in_proj_weight[-config.hidden_size :, :] lowercase__ = in_proj_bias[-config.hidden_size :] def _a ( SCREAMING_SNAKE_CASE ): """simple docstring""" if "backbone" in name: lowercase__ = name.replace('''backbone''' , '''vit''' ) if "cls_token" in name: lowercase__ = name.replace('''cls_token''' , '''embeddings.cls_token''' ) if "det_token" in name: lowercase__ = name.replace('''det_token''' , '''embeddings.detection_tokens''' ) if "mid_pos_embed" in name: lowercase__ = name.replace('''mid_pos_embed''' , '''encoder.mid_position_embeddings''' ) if "pos_embed" in name: lowercase__ = name.replace('''pos_embed''' , '''embeddings.position_embeddings''' ) if "patch_embed.proj" in name: lowercase__ = name.replace('''patch_embed.proj''' , '''embeddings.patch_embeddings.projection''' ) if "blocks" in name: lowercase__ = name.replace('''blocks''' , '''encoder.layer''' ) if "attn.proj" in name: lowercase__ = name.replace('''attn.proj''' , '''attention.output.dense''' ) if "attn" in name: lowercase__ = name.replace('''attn''' , '''attention.self''' ) if "norm1" in name: lowercase__ = name.replace('''norm1''' , '''layernorm_before''' ) if "norm2" in name: lowercase__ = name.replace('''norm2''' , '''layernorm_after''' ) if "mlp.fc1" in name: lowercase__ = name.replace('''mlp.fc1''' , '''intermediate.dense''' ) if "mlp.fc2" in name: lowercase__ = name.replace('''mlp.fc2''' , '''output.dense''' ) if "class_embed" in name: lowercase__ = name.replace('''class_embed''' , '''class_labels_classifier''' ) if "bbox_embed" in name: lowercase__ = name.replace('''bbox_embed''' , '''bbox_predictor''' ) if "vit.norm" in name: lowercase__ = name.replace('''vit.norm''' , '''vit.layernorm''' ) return name def _a ( SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE ): """simple docstring""" for key in orig_state_dict.copy().keys(): lowercase__ = orig_state_dict.pop(SCREAMING_SNAKE_CASE ) if "qkv" in key: lowercase__ = key.split('''.''' ) lowercase__ = int(key_split[2] ) lowercase__ = model.vit.encoder.layer[layer_num].attention.attention.all_head_size if "weight" in key: lowercase__ = val[:dim, :] lowercase__ = val[ dim : dim * 2, : ] lowercase__ = val[-dim:, :] else: lowercase__ = val[:dim] lowercase__ = val[dim : dim * 2] lowercase__ = val[-dim:] else: lowercase__ = val return orig_state_dict def _a ( ): """simple docstring""" lowercase__ = '''http://images.cocodataset.org/val2017/000000039769.jpg''' lowercase__ = Image.open(requests.get(SCREAMING_SNAKE_CASE , stream=SCREAMING_SNAKE_CASE ).raw ) return im @torch.no_grad() def _a ( SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = False ): """simple docstring""" lowercase__ = get_yolos_config(SCREAMING_SNAKE_CASE ) # load original state_dict lowercase__ = torch.load(SCREAMING_SNAKE_CASE , map_location='''cpu''' )['''model'''] # load 🤗 model lowercase__ = YolosForObjectDetection(SCREAMING_SNAKE_CASE ) model.eval() lowercase__ = convert_state_dict(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE ) model.load_state_dict(SCREAMING_SNAKE_CASE ) # Check outputs on an image, prepared by YolosImageProcessor lowercase__ = 8_00 if yolos_name != '''yolos_ti''' else 5_12 lowercase__ = YolosImageProcessor(format='''coco_detection''' , size=SCREAMING_SNAKE_CASE ) lowercase__ = image_processor(images=prepare_img() , return_tensors='''pt''' ) lowercase__ = model(**SCREAMING_SNAKE_CASE ) lowercase__ , lowercase__ = outputs.logits, outputs.pred_boxes lowercase__ , lowercase__ = None, None if yolos_name == "yolos_ti": lowercase__ = torch.tensor( [[-39.5_022, -11.9_820, -17.6_888], [-29.9_574, -9.9_769, -17.7_691], [-42.3_281, -20.7_200, -30.6_294]] ) lowercase__ = torch.tensor( [[0.4_021, 0.0_836, 0.7_979], [0.0_184, 0.2_609, 0.0_364], [0.1_781, 0.2_004, 0.2_095]] ) elif yolos_name == "yolos_s_200_pre": lowercase__ = torch.tensor( [[-24.0_248, -10.3_024, -14.8_290], [-42.0_392, -16.8_200, -27.4_334], [-27.2_743, -11.8_154, -18.7_148]] ) lowercase__ = torch.tensor( [[0.2_559, 0.5_455, 0.4_706], [0.2_989, 0.7_279, 0.1_875], [0.7_732, 0.4_017, 0.4_462]] ) elif yolos_name == "yolos_s_300_pre": lowercase__ = torch.tensor( [[-36.2_220, -14.4_385, -23.5_457], [-35.6_970, -14.7_583, -21.3_935], [-31.5_939, -13.6_042, -16.8_049]] ) lowercase__ = torch.tensor( [[0.7_614, 0.2_316, 0.4_728], [0.7_168, 0.4_495, 0.3_855], [0.4_996, 0.1_466, 0.9_996]] ) elif yolos_name == "yolos_s_dWr": lowercase__ = torch.tensor( [[-42.8_668, -24.1_049, -41.1_690], [-34.7_456, -14.1_274, -24.9_194], [-33.7_898, -12.1_946, -25.6_495]] ) lowercase__ = torch.tensor( [[0.5_587, 0.2_773, 0.0_605], [0.5_004, 0.3_014, 0.9_994], [0.4_999, 0.1_548, 0.9_994]] ) elif yolos_name == "yolos_base": lowercase__ = torch.tensor( [[-40.6_064, -24.3_084, -32.6_447], [-55.1_990, -30.7_719, -35.5_877], [-51.4_311, -33.3_507, -35.6_462]] ) lowercase__ = torch.tensor( [[0.5_555, 0.2_794, 0.0_655], [0.9_049, 0.2_664, 0.1_894], [0.9_183, 0.1_984, 0.1_635]] ) else: raise ValueError(f'Unknown yolos_name: {yolos_name}' ) assert torch.allclose(logits[0, :3, :3] , SCREAMING_SNAKE_CASE , atol=1E-4 ) assert torch.allclose(pred_boxes[0, :3, :3] , SCREAMING_SNAKE_CASE , atol=1E-4 ) Path(SCREAMING_SNAKE_CASE ).mkdir(exist_ok=SCREAMING_SNAKE_CASE ) print(f'Saving model {yolos_name} to {pytorch_dump_folder_path}' ) model.save_pretrained(SCREAMING_SNAKE_CASE ) print(f'Saving image processor to {pytorch_dump_folder_path}' ) image_processor.save_pretrained(SCREAMING_SNAKE_CASE ) if push_to_hub: lowercase__ = { '''yolos_ti''': '''yolos-tiny''', '''yolos_s_200_pre''': '''yolos-small''', '''yolos_s_300_pre''': '''yolos-small-300''', '''yolos_s_dWr''': '''yolos-small-dwr''', '''yolos_base''': '''yolos-base''', } print('''Pushing to the hub...''' ) lowercase__ = model_mapping[yolos_name] image_processor.push_to_hub(SCREAMING_SNAKE_CASE , organization='''hustvl''' ) model.push_to_hub(SCREAMING_SNAKE_CASE , organization='''hustvl''' ) if __name__ == "__main__": lowerCAmelCase = argparse.ArgumentParser() # Required parameters parser.add_argument( '--yolos_name', default='yolos_s_200_pre', type=str, help=( 'Name of the YOLOS model you\'d like to convert. Should be one of \'yolos_ti\', \'yolos_s_200_pre\',' ' \'yolos_s_300_pre\', \'yolos_s_dWr\', \'yolos_base\'.' ), ) parser.add_argument( '--checkpoint_path', default=None, type=str, help='Path to the original state dict (.pth file).' ) parser.add_argument( '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.' ) parser.add_argument( '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.' ) lowerCAmelCase = parser.parse_args() convert_yolos_checkpoint(args.yolos_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub)
110
from pickle import UnpicklingError import jax import jax.numpy as jnp import numpy as np from flax.serialization import from_bytes from flax.traverse_util import flatten_dict from ..utils import logging lowerCAmelCase = logging.get_logger(__name__) def _a ( SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE ): """simple docstring""" try: with open(SCREAMING_SNAKE_CASE , '''rb''' ) as flax_state_f: lowercase__ = from_bytes(SCREAMING_SNAKE_CASE , flax_state_f.read() ) except UnpicklingError as e: try: with open(SCREAMING_SNAKE_CASE ) as f: if f.read().startswith('''version''' ): raise OSError( '''You seem to have cloned a repository without having git-lfs installed. Please''' ''' install git-lfs and run `git lfs install` followed by `git lfs pull` in the''' ''' folder you cloned.''' ) else: raise ValueError from e except (UnicodeDecodeError, ValueError): raise EnvironmentError(f'Unable to convert {model_file} to Flax deserializable object. ' ) return load_flax_weights_in_pytorch_model(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE ) def _a ( SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE ): """simple docstring""" try: import torch # noqa: F401 except ImportError: logger.error( '''Loading Flax weights in PyTorch requires both PyTorch and Flax to be installed. Please see''' ''' https://pytorch.org/ and https://flax.readthedocs.io/en/latest/installation.html for installation''' ''' instructions.''' ) raise # check if we have bf16 weights lowercase__ = flatten_dict(jax.tree_util.tree_map(lambda SCREAMING_SNAKE_CASE : x.dtype == jnp.bfloataa , SCREAMING_SNAKE_CASE ) ).values() if any(SCREAMING_SNAKE_CASE ): # convert all weights to fp32 if they are bf16 since torch.from_numpy can-not handle bf16 # and bf16 is not fully supported in PT yet. logger.warning( '''Found ``bfloat16`` weights in Flax model. Casting all ``bfloat16`` weights to ``float32`` ''' '''before loading those in PyTorch model.''' ) lowercase__ = jax.tree_util.tree_map( lambda SCREAMING_SNAKE_CASE : params.astype(np.floataa ) if params.dtype == jnp.bfloataa else params , SCREAMING_SNAKE_CASE ) lowercase__ = '''''' lowercase__ = flatten_dict(SCREAMING_SNAKE_CASE , sep='''.''' ) lowercase__ = pt_model.state_dict() # keep track of unexpected & missing keys lowercase__ = [] lowercase__ = set(pt_model_dict.keys() ) for flax_key_tuple, flax_tensor in flax_state_dict.items(): lowercase__ = flax_key_tuple.split('''.''' ) if flax_key_tuple_array[-1] == "kernel" and flax_tensor.ndim == 4: lowercase__ = flax_key_tuple_array[:-1] + ['''weight'''] lowercase__ = jnp.transpose(SCREAMING_SNAKE_CASE , (3, 2, 0, 1) ) elif flax_key_tuple_array[-1] == "kernel": lowercase__ = flax_key_tuple_array[:-1] + ['''weight'''] lowercase__ = flax_tensor.T elif flax_key_tuple_array[-1] == "scale": lowercase__ = flax_key_tuple_array[:-1] + ['''weight'''] if "time_embedding" not in flax_key_tuple_array: for i, flax_key_tuple_string in enumerate(SCREAMING_SNAKE_CASE ): lowercase__ = ( flax_key_tuple_string.replace('''_0''' , '''.0''' ) .replace('''_1''' , '''.1''' ) .replace('''_2''' , '''.2''' ) .replace('''_3''' , '''.3''' ) .replace('''_4''' , '''.4''' ) .replace('''_5''' , '''.5''' ) .replace('''_6''' , '''.6''' ) .replace('''_7''' , '''.7''' ) .replace('''_8''' , '''.8''' ) .replace('''_9''' , '''.9''' ) ) lowercase__ = '''.'''.join(SCREAMING_SNAKE_CASE ) if flax_key in pt_model_dict: if flax_tensor.shape != pt_model_dict[flax_key].shape: raise ValueError( f'Flax checkpoint seems to be incorrect. Weight {flax_key_tuple} was expected ' f'to be of shape {pt_model_dict[flax_key].shape}, but is {flax_tensor.shape}.' ) else: # add weight to pytorch dict lowercase__ = np.asarray(SCREAMING_SNAKE_CASE ) if not isinstance(SCREAMING_SNAKE_CASE , np.ndarray ) else flax_tensor lowercase__ = torch.from_numpy(SCREAMING_SNAKE_CASE ) # remove from missing keys missing_keys.remove(SCREAMING_SNAKE_CASE ) else: # weight is not expected by PyTorch model unexpected_keys.append(SCREAMING_SNAKE_CASE ) pt_model.load_state_dict(SCREAMING_SNAKE_CASE ) # re-transform missing_keys to list lowercase__ = list(SCREAMING_SNAKE_CASE ) if len(SCREAMING_SNAKE_CASE ) > 0: logger.warning( '''Some weights of the Flax model were not used when initializing the PyTorch model''' f' {pt_model.__class__.__name__}: {unexpected_keys}\n- This IS expected if you are initializing' f' {pt_model.__class__.__name__} from a Flax model trained on another task or with another architecture' ''' (e.g. initializing a BertForSequenceClassification model from a FlaxBertForPreTraining model).\n- This''' f' IS NOT expected if you are initializing {pt_model.__class__.__name__} from a Flax model that you expect' ''' to be exactly identical (e.g. initializing a BertForSequenceClassification model from a''' ''' FlaxBertForSequenceClassification model).''' ) if len(SCREAMING_SNAKE_CASE ) > 0: logger.warning( f'Some weights of {pt_model.__class__.__name__} were not initialized from the Flax model and are newly' f' initialized: {missing_keys}\nYou should probably TRAIN this model on a down-stream task to be able to' ''' use it for predictions and inference.''' ) return pt_model
110
1
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''') A : Optional[Any] = logging.getLogger(__name__) @dataclass class __lowerCamelCase : """simple docstring""" a = field( metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"} ) a = field( default=a_ , metadata={"help": "Pretrained config name or path if not the same as model_name"} ) a = field( default=a_ , metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"} ) a = field( default=a_ , metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"} , ) a = field( default=a_ , metadata={"help": "Whether to use one of the fast tokenizer (backed by the tokenizers library) or not."} , ) a = field( default="main" , metadata={"help": "The specific model version to use (can be a branch name, tag name or commit id)."} , ) a = field( default=a_ , metadata={ "help": ( "Will use the token generated when running `huggingface-cli login` (necessary to use this script " "with private models)." ) } , ) @dataclass class __lowerCamelCase : """simple docstring""" a = field(default=a_ , metadata={"help": "The input training data file (a text file)."} ) a = field( default=a_ , metadata={"help": "An optional input evaluation data file to evaluate the perplexity on (a text file)."} , ) a = field( default=a_ , metadata={"help": "Overwrite the cached training and evaluation sets"} ) a = field( default=a_ , metadata={"help": "The number of processes to use for the preprocessing."} , ) a = field( default=a_ , metadata={ "help": ( "The maximum total input sequence length after tokenization. If passed, sequences longer " "than this will be truncated, sequences shorter will be padded." ) } , ) a = field( default=a_ , metadata={ "help": ( "Whether to pad all samples to the maximum sentence length. " "If False, will pad the samples dynamically when batching to the maximum length in the batch. More " "efficient on GPU but very bad for TPU." ) } , ) a = field( default=a_ , metadata={ "help": ( "For debugging purposes or quicker training, truncate the number of training examples to this " "value if set." ) } , ) a = field( default=a_ , metadata={ "help": ( "For debugging purposes or quicker training, truncate the number of evaluation examples to this " "value if set." ) } , ) def A ( self : List[Any]): if self.train_file is not None: _A : Union[str, Any] = 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: _A : str = self.validation_file.split('.')[-1] assert extension in ["csv", "json"], "`validation_file` should be a csv or a json file." @dataclass class __lowerCamelCase : """simple docstring""" a = 42 a = True a = None a = None def __call__( self : Dict , SCREAMING_SNAKE_CASE : Any): _A : Any = 'label' if 'label' in features[0].keys() else 'labels' _A : Optional[Any] = [feature.pop(__lowerCAmelCase) for feature in features] _A : List[Any] = len(__lowerCAmelCase) _A : Dict = len(features[0]['input_ids']) _A : List[str] = [ [{k: v[i] for k, v in feature.items()} for i in range(__lowerCAmelCase)] for feature in features ] _A : Optional[Any] = list(chain(*__lowerCAmelCase)) _A : Union[str, Any] = self.tokenizer.pad( __lowerCAmelCase , padding=self.padding , max_length=self.max_length , pad_to_multiple_of=self.pad_to_multiple_of , return_tensors='pt' , ) # Un-flatten _A : Tuple = {k: v.view(__lowerCAmelCase , __lowerCAmelCase , -1) for k, v in batch.items()} # Add back labels _A : Dict = torch.tensor(__lowerCAmelCase , dtype=torch.intaa) return batch def lowerCAmelCase__ ( ): _A : List[Any] = 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. _A , _A , _A : str = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1] ) ) else: _A , _A , _A : Optional[Any] = 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() _A : List[Any] = training_args.get_process_log_level() logger.setLevel(lowerCAmelCase__ ) datasets.utils.logging.set_verbosity(lowerCAmelCase__ ) transformers.utils.logging.set_verbosity(lowerCAmelCase__ ) transformers.utils.logging.enable_default_handler() transformers.utils.logging.enable_explicit_format() # Log on each process the small summary: logger.warning( F'Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}' + F'distributed training: {bool(training_args.local_rank != -1 )}, 16-bits training: {training_args.fpaa}' ) logger.info(F'Training/evaluation parameters {training_args}' ) # Detecting last checkpoint. _A : int = None if os.path.isdir(training_args.output_dir ) and training_args.do_train and not training_args.overwrite_output_dir: _A : Any = get_last_checkpoint(training_args.output_dir ) if last_checkpoint is None and len(os.listdir(training_args.output_dir ) ) > 0: raise ValueError( F'Output directory ({training_args.output_dir}) already exists and is not empty. ' 'Use --overwrite_output_dir to overcome.' ) elif last_checkpoint is not None and training_args.resume_from_checkpoint is None: logger.info( F'Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change ' 'the `--output_dir` or add `--overwrite_output_dir` to train from scratch.' ) # Set seed before initializing model. set_seed(training_args.seed ) # Get the datasets: you can either provide your own CSV/JSON/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: _A : int = {} if data_args.train_file is not None: _A : Any = data_args.train_file if data_args.validation_file is not None: _A : Any = data_args.validation_file _A : Union[str, Any] = data_args.train_file.split('.' )[-1] _A : List[Any] = 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. _A : List[str] = 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. _A : Tuple = 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 ,) _A : Union[str, Any] = 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 ,) _A : Optional[int] = 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. _A : Tuple = [F'ending{i}' for i in range(4 )] _A : int = 'sent1' _A : int = 'sent2' if data_args.max_seq_length is None: _A : Any = 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`.' ) _A : Optional[Any] = 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}.' ) _A : List[str] = min(data_args.max_seq_length ,tokenizer.model_max_length ) # Preprocessing the datasets. def preprocess_function(lowerCamelCase : Optional[Any] ): _A : Optional[Any] = [[context] * 4 for context in examples[context_name]] _A : Optional[Any] = examples[question_header_name] _A : str = [ [F'{header} {examples[end][i]}' for end in ending_names] for i, header in enumerate(lowerCAmelCase__ ) ] # Flatten out _A : Optional[Any] = list(chain(*lowerCAmelCase__ ) ) _A : Optional[Any] = list(chain(*lowerCAmelCase__ ) ) # Tokenize _A : List[str] = 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' ) _A : List[Any] = raw_datasets['train'] if data_args.max_train_samples is not None: _A : List[str] = min(len(lowerCAmelCase__ ) ,data_args.max_train_samples ) _A : Dict = train_dataset.select(range(lowerCAmelCase__ ) ) with training_args.main_process_first(desc='train dataset map pre-processing' ): _A : Union[str, Any] = 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' ) _A : Optional[Any] = raw_datasets['validation'] if data_args.max_eval_samples is not None: _A : int = min(len(lowerCAmelCase__ ) ,data_args.max_eval_samples ) _A : int = eval_dataset.select(range(lowerCAmelCase__ ) ) with training_args.main_process_first(desc='validation dataset map pre-processing' ): _A : int = eval_dataset.map( lowerCAmelCase__ ,batched=lowerCAmelCase__ ,num_proc=data_args.preprocessing_num_workers ,load_from_cache_file=not data_args.overwrite_cache ,) # Data collator _A : int = ( default_data_collator if data_args.pad_to_max_length else DataCollatorForMultipleChoice(tokenizer=lowerCAmelCase__ ,pad_to_multiple_of=8 if training_args.fpaa else None ) ) # Metric def compute_metrics(lowerCamelCase : Optional[Any] ): _A , _A : Dict = eval_predictions _A : int = np.argmax(lowerCAmelCase__ ,axis=1 ) return {"accuracy": (preds == label_ids).astype(np.floataa ).mean().item()} # Initialize our Trainer _A : Union[str, Any] = 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: _A : int = None if training_args.resume_from_checkpoint is not None: _A : Optional[int] = training_args.resume_from_checkpoint elif last_checkpoint is not None: _A : Optional[int] = last_checkpoint _A : Optional[Any] = trainer.train(resume_from_checkpoint=lowerCAmelCase__ ) trainer.save_model() # Saves the tokenizer too for easy upload _A : int = train_result.metrics _A : List[str] = ( data_args.max_train_samples if data_args.max_train_samples is not None else len(lowerCAmelCase__ ) ) _A : Optional[Any] = 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 ***' ) _A : Optional[int] = trainer.evaluate() _A : Optional[int] = data_args.max_eval_samples if data_args.max_eval_samples is not None else len(lowerCAmelCase__ ) _A : List[Any] = min(lowerCAmelCase__ ,len(lowerCAmelCase__ ) ) trainer.log_metrics('eval' ,lowerCAmelCase__ ) trainer.save_metrics('eval' ,lowerCAmelCase__ ) _A : Optional[Any] = { 'finetuned_from': model_args.model_name_or_path, 'tasks': 'multiple-choice', 'dataset_tags': 'swag', 'dataset_args': 'regular', 'dataset': 'SWAG', 'language': 'en', } if training_args.push_to_hub: trainer.push_to_hub(**lowerCAmelCase__ ) else: trainer.create_model_card(**lowerCAmelCase__ ) def lowerCAmelCase__ ( lowerCamelCase : Union[str, Any] ): main() if __name__ == "__main__": main()
360
'''simple docstring''' from __future__ import annotations class __lowerCamelCase : """simple docstring""" def __init__( self : Optional[Any] , SCREAMING_SNAKE_CASE : Tuple=None): _A : Any = data _A : Optional[Any] = None def __repr__( self : List[str]): _A : List[Any] = [] _A : Any = self while temp: string_rep.append(F'{temp.data}') _A : List[Any] = temp.next return "->".join(SCREAMING_SNAKE_CASE) def lowerCAmelCase__ ( lowerCamelCase : list ): if not elements_list: raise Exception('The Elements List is empty' ) _A : Union[str, Any] = Node(elements_list[0] ) for i in range(1 ,len(lowerCamelCase ) ): _A : Dict = Node(elements_list[i] ) _A : int = current.next return head def lowerCAmelCase__ ( lowerCamelCase : Node ): if head_node is not None and isinstance(lowerCamelCase ,lowerCamelCase ): print_reverse(head_node.next ) print(head_node.data ) def lowerCAmelCase__ ( ): from doctest import testmod testmod() _A : List[str] = make_linked_list([14, 52, 14, 12, 43] ) print('Linked List:' ) print(lowerCamelCase ) print('Elements in Reverse:' ) print_reverse(lowerCamelCase ) if __name__ == "__main__": main()
227
0
from collections import OrderedDict from typing import Mapping from packaging import version from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices lowerCAmelCase__ = logging.get_logger(__name__) lowerCAmelCase__ = { """microsoft/swin-tiny-patch4-window7-224""": ( """https://huggingface.co/microsoft/swin-tiny-patch4-window7-224/resolve/main/config.json""" ), # See all Swin models at https://huggingface.co/models?filter=swin } class a__ ( snake_case , snake_case ): """simple docstring""" __lowerCamelCase = 'swin' __lowerCamelCase = { 'num_attention_heads': 'num_heads', 'num_hidden_layers': 'num_layers', } def __init__( self , lowercase=224 , lowercase=4 , lowercase=3 , lowercase=96 , lowercase=[2, 2, 6, 2] , lowercase=[3, 6, 12, 24] , lowercase=7 , lowercase=4.0 , lowercase=True , lowercase=0.0 , lowercase=0.0 , lowercase=0.1 , lowercase="gelu" , lowercase=False , lowercase=0.02 , lowercase=1e-5 , lowercase=32 , lowercase=None , lowercase=None , **lowercase , ) -> Union[str, Any]: '''simple docstring''' super().__init__(**lowercase ) A__ = image_size A__ = patch_size A__ = num_channels A__ = embed_dim A__ = depths A__ = len(lowercase ) A__ = num_heads A__ = window_size A__ = mlp_ratio A__ = qkv_bias A__ = hidden_dropout_prob A__ = attention_probs_dropout_prob A__ = drop_path_rate A__ = hidden_act A__ = use_absolute_embeddings A__ = layer_norm_eps A__ = initializer_range A__ = encoder_stride # we set the hidden_size attribute in order to make Swin work with VisionEncoderDecoderModel # this indicates the channel dimension after the last stage of the model A__ = int(embed_dim * 2 ** (len(lowercase ) - 1) ) A__ = ["stem"] + [F'stage{idx}' for idx in range(1 , len(lowercase ) + 1 )] A__ , A__ = get_aligned_output_features_output_indices( out_features=lowercase , out_indices=lowercase , stage_names=self.stage_names ) class a__ ( snake_case ): """simple docstring""" __lowerCamelCase = version.parse('1.11' ) @property def UpperCamelCase ( self ) -> Mapping[str, Mapping[int, str]]: '''simple docstring''' return OrderedDict( [ ("pixel_values", {0: "batch", 1: "num_channels", 2: "height", 3: "width"}), ] ) @property def UpperCamelCase ( self ) -> float: '''simple docstring''' return 1e-4
68
from typing import Dict, List, Optional, Union import numpy as np from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict from ...image_transforms import convert_to_rgb, normalize, rescale, resize, to_channel_dimension_format from ...image_utils import ( OPENAI_CLIP_MEAN, OPENAI_CLIP_STD, ChannelDimension, ImageInput, PILImageResampling, make_list_of_images, to_numpy_array, valid_images, ) from ...utils import TensorType, is_vision_available, logging if is_vision_available(): import PIL lowerCAmelCase__ = logging.get_logger(__name__) class a__ ( snake_case ): """simple docstring""" __lowerCamelCase = ['pixel_values'] def __init__( self , lowercase = True , lowercase = None , lowercase = PILImageResampling.BICUBIC , lowercase = True , lowercase = 1 / 255 , lowercase = True , lowercase = None , lowercase = None , lowercase = True , **lowercase , ) -> None: '''simple docstring''' super().__init__(**lowercase ) A__ = size if size is not None else {"height": 384, "width": 384} A__ = get_size_dict(lowercase , default_to_square=lowercase ) A__ = do_resize A__ = size A__ = resample A__ = do_rescale A__ = rescale_factor A__ = do_normalize A__ = image_mean if image_mean is not None else OPENAI_CLIP_MEAN A__ = image_std if image_std is not None else OPENAI_CLIP_STD A__ = do_convert_rgb def UpperCamelCase ( self , lowercase , lowercase , lowercase = PILImageResampling.BICUBIC , lowercase = None , **lowercase , ) -> np.ndarray: '''simple docstring''' A__ = get_size_dict(lowercase , default_to_square=lowercase ) if "height" not in size or "width" not in size: raise ValueError(F'The `size` dictionary must contain the keys `height` and `width`. Got {size.keys()}' ) A__ = (size["height"], size["width"]) return resize(lowercase , size=lowercase , resample=lowercase , data_format=lowercase , **lowercase ) def UpperCamelCase ( self , lowercase , lowercase , lowercase = None , **lowercase , ) -> Optional[Any]: '''simple docstring''' return rescale(lowercase , scale=lowercase , data_format=lowercase , **lowercase ) def UpperCamelCase ( self , lowercase , lowercase , lowercase , lowercase = None , **lowercase , ) -> np.ndarray: '''simple docstring''' return normalize(lowercase , mean=lowercase , std=lowercase , data_format=lowercase , **lowercase ) def UpperCamelCase ( self , lowercase , lowercase = None , lowercase = None , lowercase = None , lowercase = None , lowercase = None , lowercase = None , lowercase = None , lowercase = None , lowercase = None , lowercase = None , lowercase = ChannelDimension.FIRST , **lowercase , ) -> PIL.Image.Image: '''simple docstring''' A__ = do_resize if do_resize is not None else self.do_resize A__ = resample if resample is not None else self.resample A__ = do_rescale if do_rescale is not None else self.do_rescale A__ = rescale_factor if rescale_factor is not None else self.rescale_factor A__ = do_normalize if do_normalize is not None else self.do_normalize A__ = image_mean if image_mean is not None else self.image_mean A__ = image_std if image_std is not None else self.image_std A__ = do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb A__ = size if size is not None else self.size A__ = get_size_dict(lowercase , default_to_square=lowercase ) A__ = make_list_of_images(lowercase ) if not valid_images(lowercase ): raise ValueError( "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, " "torch.Tensor, tf.Tensor or jax.ndarray." ) if do_resize and size is None or resample is None: raise ValueError("Size and resample must be specified if do_resize is True." ) if do_rescale and rescale_factor is None: raise ValueError("Rescale factor must be specified if do_rescale is True." ) if do_normalize and (image_mean is None or image_std is None): raise ValueError("Image mean and std must be specified if do_normalize is True." ) # PIL RGBA images are converted to RGB if do_convert_rgb: A__ = [convert_to_rgb(lowercase ) for image in images] # All transformations expect numpy arrays. A__ = [to_numpy_array(lowercase ) for image in images] if do_resize: A__ = [self.resize(image=lowercase , size=lowercase , resample=lowercase ) for image in images] if do_rescale: A__ = [self.rescale(image=lowercase , scale=lowercase ) for image in images] if do_normalize: A__ = [self.normalize(image=lowercase , mean=lowercase , std=lowercase ) for image in images] A__ = [to_channel_dimension_format(lowercase , lowercase ) for image in images] A__ = BatchFeature(data={"pixel_values": images} , tensor_type=lowercase ) return encoded_outputs
68
1
from typing import Callable, List, Optional, Tuple, Union import torch from transformers import CLIPTextModel, CLIPTokenizer from ...configuration_utils import ConfigMixin, register_to_config from ...models import ModelMixin, TransformeraDModel, VQModel from ...schedulers import VQDiffusionScheduler from ...utils import logging from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput __snake_case = logging.get_logger(__name__) # pylint: disable=invalid-name class __snake_case ( lowerCamelCase__ , lowerCamelCase__ ): @register_to_config def __init__( self , snake_case__ , snake_case__ = None , snake_case__ = None ) -> Optional[int]: '''simple docstring''' super().__init__() UpperCAmelCase : Union[str, Any] =learnable if self.learnable: assert hidden_size is not None, "learnable=True requires `hidden_size` to be set" assert length is not None, "learnable=True requires `length` to be set" UpperCAmelCase : Any =torch.zeros(snake_case__ , snake_case__ ) else: UpperCAmelCase : str =None UpperCAmelCase : Any =torch.nn.Parameter(snake_case__ ) class __snake_case ( lowerCamelCase__ ): __lowerCamelCase : VQModel __lowerCamelCase : CLIPTextModel __lowerCamelCase : CLIPTokenizer __lowerCamelCase : TransformeraDModel __lowerCamelCase : LearnedClassifierFreeSamplingEmbeddings __lowerCamelCase : VQDiffusionScheduler def __init__( self , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , ) -> Optional[int]: '''simple docstring''' super().__init__() self.register_modules( vqvae=snake_case__ , transformer=snake_case__ , text_encoder=snake_case__ , tokenizer=snake_case__ , scheduler=snake_case__ , learned_classifier_free_sampling_embeddings=snake_case__ , ) def UpperCAmelCase__ ( self , snake_case__ , snake_case__ , snake_case__ ) -> Tuple: '''simple docstring''' UpperCAmelCase : Union[str, Any] =len(snake_case__ ) if isinstance(snake_case__ , snake_case__ ) else 1 # get prompt text embeddings UpperCAmelCase : Tuple =self.tokenizer( snake_case__ , padding='''max_length''' , max_length=self.tokenizer.model_max_length , return_tensors='''pt''' , ) UpperCAmelCase : Tuple =text_inputs.input_ids if text_input_ids.shape[-1] > self.tokenizer.model_max_length: UpperCAmelCase : Optional[Any] =self.tokenizer.batch_decode(text_input_ids[:, self.tokenizer.model_max_length :] ) logger.warning( '''The following part of your input was truncated because CLIP can only handle sequences up to''' f''' {self.tokenizer.model_max_length} tokens: {removed_text}''' ) UpperCAmelCase : Dict =text_input_ids[:, : self.tokenizer.model_max_length] UpperCAmelCase : str =self.text_encoder(text_input_ids.to(self.device ) )[0] # NOTE: This additional step of normalizing the text embeddings is from VQ-Diffusion. # While CLIP does normalize the pooled output of the text transformer when combining # the image and text embeddings, CLIP does not directly normalize the last hidden state. # # CLIP normalizing the pooled output. # https://github.com/huggingface/transformers/blob/d92e22d1f28324f513f3080e5c47c071a3916721/src/transformers/models/clip/modeling_clip.py#L1052-L1053 UpperCAmelCase : Dict =prompt_embeds / prompt_embeds.norm(dim=-1 , keepdim=snake_case__ ) # duplicate text embeddings for each generation per prompt UpperCAmelCase : Optional[int] =prompt_embeds.repeat_interleave(snake_case__ , dim=0 ) if do_classifier_free_guidance: if self.learned_classifier_free_sampling_embeddings.learnable: UpperCAmelCase : Any =self.learned_classifier_free_sampling_embeddings.embeddings UpperCAmelCase : int =negative_prompt_embeds.unsqueeze(0 ).repeat(snake_case__ , 1 , 1 ) else: UpperCAmelCase : Any =[''''''] * batch_size UpperCAmelCase : List[Any] =text_input_ids.shape[-1] UpperCAmelCase : Optional[Any] =self.tokenizer( snake_case__ , padding='''max_length''' , max_length=snake_case__ , truncation=snake_case__ , return_tensors='''pt''' , ) UpperCAmelCase : Optional[int] =self.text_encoder(uncond_input.input_ids.to(self.device ) )[0] # See comment for normalizing text embeddings UpperCAmelCase : List[str] =negative_prompt_embeds / negative_prompt_embeds.norm(dim=-1 , keepdim=snake_case__ ) # duplicate unconditional embeddings for each generation per prompt, using mps friendly method UpperCAmelCase : Optional[Any] =negative_prompt_embeds.shape[1] UpperCAmelCase : Tuple =negative_prompt_embeds.repeat(1 , snake_case__ , 1 ) UpperCAmelCase : Dict =negative_prompt_embeds.view(batch_size * num_images_per_prompt , snake_case__ , -1 ) # For classifier free guidance, we need to do two forward passes. # Here we concatenate the unconditional and text embeddings into a single batch # to avoid doing two forward passes UpperCAmelCase : Any =torch.cat([negative_prompt_embeds, prompt_embeds] ) return prompt_embeds @torch.no_grad() def __call__( self , snake_case__ , snake_case__ = 100 , snake_case__ = 5.0 , snake_case__ = 1.0 , snake_case__ = 1 , snake_case__ = None , snake_case__ = None , snake_case__ = "pil" , snake_case__ = True , snake_case__ = None , snake_case__ = 1 , ) -> Union[ImagePipelineOutput, Tuple]: '''simple docstring''' if isinstance(snake_case__ , snake_case__ ): UpperCAmelCase : List[Any] =1 elif isinstance(snake_case__ , snake_case__ ): UpperCAmelCase : str =len(snake_case__ ) else: raise ValueError(f'''`prompt` has to be of type `str` or `list` but is {type(snake_case__ )}''' ) UpperCAmelCase : Any =batch_size * num_images_per_prompt UpperCAmelCase : Optional[Any] =guidance_scale > 1.0 UpperCAmelCase : Optional[int] =self._encode_prompt(snake_case__ , snake_case__ , snake_case__ ) if (callback_steps is None) or ( callback_steps is not None and (not isinstance(snake_case__ , snake_case__ ) or callback_steps <= 0) ): raise ValueError( f'''`callback_steps` has to be a positive integer but is {callback_steps} of type''' f''' {type(snake_case__ )}.''' ) # get the initial completely masked latents unless the user supplied it UpperCAmelCase : Tuple =(batch_size, self.transformer.num_latent_pixels) if latents is None: UpperCAmelCase : Union[str, Any] =self.transformer.num_vector_embeds - 1 UpperCAmelCase : Union[str, Any] =torch.full(snake_case__ , snake_case__ ).to(self.device ) else: if latents.shape != latents_shape: raise ValueError(f'''Unexpected latents shape, got {latents.shape}, expected {latents_shape}''' ) if (latents < 0).any() or (latents >= self.transformer.num_vector_embeds).any(): raise ValueError( '''Unexpected latents value(s). All latents be valid embedding indices i.e. in the range 0,''' f''' {self.transformer.num_vector_embeds - 1} (inclusive).''' ) UpperCAmelCase : Optional[Any] =latents.to(self.device ) # set timesteps self.scheduler.set_timesteps(snake_case__ , device=self.device ) UpperCAmelCase : Tuple =self.scheduler.timesteps.to(self.device ) UpperCAmelCase : Dict =latents for i, t in enumerate(self.progress_bar(snake_case__ ) ): # expand the sample if we are doing classifier free guidance UpperCAmelCase : Optional[Any] =torch.cat([sample] * 2 ) if do_classifier_free_guidance else sample # predict the un-noised image # model_output == `log_p_x_0` UpperCAmelCase : Union[str, Any] =self.transformer(snake_case__ , encoder_hidden_states=snake_case__ , timestep=snake_case__ ).sample if do_classifier_free_guidance: UpperCAmelCase , UpperCAmelCase : str =model_output.chunk(2 ) UpperCAmelCase : Union[str, Any] =model_output_uncond + guidance_scale * (model_output_text - model_output_uncond) model_output -= torch.logsumexp(snake_case__ , dim=1 , keepdim=snake_case__ ) UpperCAmelCase : Dict =self.truncate(snake_case__ , snake_case__ ) # remove `log(0)`'s (`-inf`s) UpperCAmelCase : Optional[int] =model_output.clamp(-70 ) # compute the previous noisy sample x_t -> x_t-1 UpperCAmelCase : List[str] =self.scheduler.step(snake_case__ , timestep=snake_case__ , sample=snake_case__ , generator=snake_case__ ).prev_sample # call the callback, if provided if callback is not None and i % callback_steps == 0: callback(snake_case__ , snake_case__ , snake_case__ ) UpperCAmelCase : Union[str, Any] =self.vqvae.config.vq_embed_dim UpperCAmelCase : str =(batch_size, self.transformer.height, self.transformer.width, embedding_channels) UpperCAmelCase : Optional[int] =self.vqvae.quantize.get_codebook_entry(snake_case__ , shape=snake_case__ ) UpperCAmelCase : List[str] =self.vqvae.decode(snake_case__ , force_not_quantize=snake_case__ ).sample UpperCAmelCase : List[Any] =(image / 2 + 0.5).clamp(0 , 1 ) UpperCAmelCase : Tuple =image.cpu().permute(0 , 2 , 3 , 1 ).numpy() if output_type == "pil": UpperCAmelCase : List[str] =self.numpy_to_pil(snake_case__ ) if not return_dict: return (image,) return ImagePipelineOutput(images=snake_case__ ) def UpperCAmelCase__ ( self , snake_case__ , snake_case__ ) -> torch.FloatTensor: '''simple docstring''' UpperCAmelCase , UpperCAmelCase : Tuple =torch.sort(snake_case__ , 1 , descending=snake_case__ ) UpperCAmelCase : List[str] =torch.exp(snake_case__ ) UpperCAmelCase : List[str] =sorted_p_x_0.cumsum(dim=1 ) < truncation_rate # Ensure that at least the largest probability is not zeroed out UpperCAmelCase : int =torch.full_like(keep_mask[:, 0:1, :] , snake_case__ ) UpperCAmelCase : str =torch.cat((all_true, keep_mask) , dim=1 ) UpperCAmelCase : int =keep_mask[:, :-1, :] UpperCAmelCase : Union[str, Any] =keep_mask.gather(1 , indices.argsort(1 ) ) UpperCAmelCase : Any =log_p_x_0.clone() UpperCAmelCase : Dict =-torch.inf # -inf = log(0) return rv
78
import functools import logging import os import sys import threading from logging import ( CRITICAL, # NOQA DEBUG, # NOQA ERROR, # NOQA FATAL, # NOQA INFO, # NOQA NOTSET, # NOQA WARN, # NOQA WARNING, # NOQA ) from typing import Optional import huggingface_hub.utils as hf_hub_utils from tqdm import auto as tqdm_lib __snake_case = threading.Lock() __snake_case = None __snake_case = { '''debug''': logging.DEBUG, '''info''': logging.INFO, '''warning''': logging.WARNING, '''error''': logging.ERROR, '''critical''': logging.CRITICAL, } __snake_case = logging.WARNING __snake_case = True def lowerCAmelCase_ ( )-> List[str]: '''simple docstring''' UpperCAmelCase : Optional[int] =os.getenv('''TRANSFORMERS_VERBOSITY''' , __lowerCAmelCase ) if env_level_str: if env_level_str in log_levels: return log_levels[env_level_str] else: logging.getLogger().warning( f'''Unknown option TRANSFORMERS_VERBOSITY={env_level_str}, ''' f'''has to be one of: { ', '.join(log_levels.keys() ) }''' ) return _default_log_level def lowerCAmelCase_ ( )-> str: '''simple docstring''' return __name__.split('''.''' )[0] def lowerCAmelCase_ ( )-> logging.Logger: '''simple docstring''' return logging.getLogger(_get_library_name() ) def lowerCAmelCase_ ( )-> None: '''simple docstring''' global _default_handler with _lock: if _default_handler: # This library has already configured the library root logger. return UpperCAmelCase : Union[str, Any] =logging.StreamHandler() # Set sys.stderr as stream. UpperCAmelCase : str =sys.stderr.flush # Apply our default configuration to the library root logger. UpperCAmelCase : List[Any] =_get_library_root_logger() library_root_logger.addHandler(_default_handler ) library_root_logger.setLevel(_get_default_logging_level() ) UpperCAmelCase : Optional[int] =False def lowerCAmelCase_ ( )-> None: '''simple docstring''' global _default_handler with _lock: if not _default_handler: return UpperCAmelCase : str =_get_library_root_logger() library_root_logger.removeHandler(_default_handler ) library_root_logger.setLevel(logging.NOTSET ) UpperCAmelCase : Optional[Any] =None def lowerCAmelCase_ ( )-> Tuple: '''simple docstring''' return log_levels def lowerCAmelCase_ ( __lowerCAmelCase = None )-> logging.Logger: '''simple docstring''' if name is None: UpperCAmelCase : int =_get_library_name() _configure_library_root_logger() return logging.getLogger(__lowerCAmelCase ) def lowerCAmelCase_ ( )-> int: '''simple docstring''' _configure_library_root_logger() return _get_library_root_logger().getEffectiveLevel() def lowerCAmelCase_ ( __lowerCAmelCase )-> None: '''simple docstring''' _configure_library_root_logger() _get_library_root_logger().setLevel(__lowerCAmelCase ) def lowerCAmelCase_ ( )-> Optional[int]: '''simple docstring''' return set_verbosity(__lowerCAmelCase ) def lowerCAmelCase_ ( )-> Tuple: '''simple docstring''' return set_verbosity(__lowerCAmelCase ) def lowerCAmelCase_ ( )-> Any: '''simple docstring''' return set_verbosity(__lowerCAmelCase ) def lowerCAmelCase_ ( )-> Dict: '''simple docstring''' return set_verbosity(__lowerCAmelCase ) def lowerCAmelCase_ ( )-> None: '''simple docstring''' _configure_library_root_logger() assert _default_handler is not None _get_library_root_logger().removeHandler(_default_handler ) def lowerCAmelCase_ ( )-> None: '''simple docstring''' _configure_library_root_logger() assert _default_handler is not None _get_library_root_logger().addHandler(_default_handler ) def lowerCAmelCase_ ( __lowerCAmelCase )-> None: '''simple docstring''' _configure_library_root_logger() assert handler is not None _get_library_root_logger().addHandler(__lowerCAmelCase ) def lowerCAmelCase_ ( __lowerCAmelCase )-> None: '''simple docstring''' _configure_library_root_logger() assert handler is not None and handler not in _get_library_root_logger().handlers _get_library_root_logger().removeHandler(__lowerCAmelCase ) def lowerCAmelCase_ ( )-> None: '''simple docstring''' _configure_library_root_logger() UpperCAmelCase : int =False def lowerCAmelCase_ ( )-> None: '''simple docstring''' _configure_library_root_logger() UpperCAmelCase : Tuple =True def lowerCAmelCase_ ( )-> None: '''simple docstring''' UpperCAmelCase : List[Any] =_get_library_root_logger().handlers for handler in handlers: UpperCAmelCase : str =logging.Formatter('''[%(levelname)s|%(filename)s:%(lineno)s] %(asctime)s >> %(message)s''' ) handler.setFormatter(__lowerCAmelCase ) def lowerCAmelCase_ ( )-> None: '''simple docstring''' UpperCAmelCase : int =_get_library_root_logger().handlers for handler in handlers: handler.setFormatter(__lowerCAmelCase ) def lowerCAmelCase_ ( self , *__lowerCAmelCase , **__lowerCAmelCase )-> Union[str, Any]: '''simple docstring''' UpperCAmelCase : Optional[Any] =os.getenv('''TRANSFORMERS_NO_ADVISORY_WARNINGS''' , __lowerCAmelCase ) if no_advisory_warnings: return self.warning(*__lowerCAmelCase , **__lowerCAmelCase ) __snake_case = warning_advice @functools.lru_cache(__lowerCAmelCase ) def lowerCAmelCase_ ( self , *__lowerCAmelCase , **__lowerCAmelCase )-> Optional[int]: '''simple docstring''' self.warning(*__lowerCAmelCase , **__lowerCAmelCase ) __snake_case = warning_once class __snake_case : def __init__( self , *snake_case__ , **snake_case__ ) -> Dict: # pylint: disable=unused-argument '''simple docstring''' UpperCAmelCase : Any =args[0] if args else None def __iter__( self ) -> List[Any]: '''simple docstring''' return iter(self._iterator ) def __getattr__( self , snake_case__ ) -> str: '''simple docstring''' def empty_fn(*snake_case__ , **snake_case__ ): # pylint: disable=unused-argument return return empty_fn def __enter__( self ) -> int: '''simple docstring''' return self def __exit__( self , snake_case__ , snake_case__ , snake_case__ ) -> List[Any]: '''simple docstring''' return class __snake_case : def __call__( self , *snake_case__ , **snake_case__ ) -> Tuple: '''simple docstring''' if _tqdm_active: return tqdm_lib.tqdm(*snake_case__ , **snake_case__ ) else: return EmptyTqdm(*snake_case__ , **snake_case__ ) def UpperCAmelCase__ ( self , *snake_case__ , **snake_case__ ) -> Any: '''simple docstring''' UpperCAmelCase : Union[str, Any] =None if _tqdm_active: return tqdm_lib.tqdm.set_lock(*snake_case__ , **snake_case__ ) def UpperCAmelCase__ ( self ) -> Optional[int]: '''simple docstring''' if _tqdm_active: return tqdm_lib.tqdm.get_lock() __snake_case = _tqdm_cls() def lowerCAmelCase_ ( )-> bool: '''simple docstring''' global _tqdm_active return bool(_tqdm_active ) def lowerCAmelCase_ ( )-> Optional[Any]: '''simple docstring''' global _tqdm_active UpperCAmelCase : Dict =True hf_hub_utils.enable_progress_bars() def lowerCAmelCase_ ( )-> Optional[Any]: '''simple docstring''' global _tqdm_active UpperCAmelCase : List[str] =False hf_hub_utils.disable_progress_bars()
78
1
import math import time from transformers import Trainer, is_torch_tpu_available from transformers.trainer_utils import PredictionOutput, speed_metrics if is_torch_tpu_available(check_device=False): import torch_xla.core.xla_model as xm import torch_xla.debug.metrics as met class A__ ( __snake_case ): def __init__( self , *A_ , A_=None , A_=None , **A_ ): '''simple docstring''' super().__init__(*A_ , **A_ ) UpperCamelCase : str = eval_examples UpperCamelCase : int = post_process_function def __UpperCamelCase( self , A_=None , A_=None , A_=None , A_ = "eval" ): '''simple docstring''' UpperCamelCase : Union[str, Any] = self.eval_dataset if eval_dataset is None else eval_dataset UpperCamelCase : str = self.get_eval_dataloader(A_ ) UpperCamelCase : List[Any] = self.eval_examples if eval_examples is None else eval_examples # Temporarily disable metric computation, we will do it in the loop here. UpperCamelCase : Dict = self.compute_metrics UpperCamelCase : Dict = None UpperCamelCase : Optional[Any] = self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop UpperCamelCase : List[str] = time.time() try: UpperCamelCase : Optional[int] = eval_loop( A_ , description="Evaluation" , prediction_loss_only=True if compute_metrics is None else None , ignore_keys=A_ , metric_key_prefix=A_ , ) finally: UpperCamelCase : Optional[Any] = compute_metrics UpperCamelCase : Tuple = self.args.eval_batch_size * self.args.world_size if F"""{metric_key_prefix}_jit_compilation_time""" in output.metrics: start_time += output.metrics[F"""{metric_key_prefix}_jit_compilation_time"""] output.metrics.update( speed_metrics( A_ , A_ , num_samples=output.num_samples , num_steps=math.ceil(output.num_samples / total_batch_size ) , ) ) if self.post_process_function is not None and self.compute_metrics is not None and self.args.should_save: # Only the main node write the results by default UpperCamelCase : Tuple = self.post_process_function(A_ , A_ , output.predictions ) UpperCamelCase : Tuple = self.compute_metrics(A_ ) # Prefix all keys with metric_key_prefix + '_' for key in list(metrics.keys() ): if not key.startswith(F"""{metric_key_prefix}_""" ): UpperCamelCase : Tuple = metrics.pop(A_ ) metrics.update(output.metrics ) else: UpperCamelCase : Union[str, Any] = output.metrics if self.args.should_log: # Only the main node log the results by default self.log(A_ ) if self.args.tpu_metrics_debug or self.args.debug: # tpu-comment: Logging debug metrics for PyTorch/XLA (compile, execute times, ops, etc.) xm.master_print(met.metrics_report() ) UpperCamelCase : Tuple = self.callback_handler.on_evaluate(self.args , self.state , self.control , A_ ) return metrics def __UpperCamelCase( self , A_ , A_ , A_=None , A_ = "test" ): '''simple docstring''' UpperCamelCase : Any = self.get_test_dataloader(A_ ) # Temporarily disable metric computation, we will do it in the loop here. UpperCamelCase : Any = self.compute_metrics UpperCamelCase : List[Any] = None UpperCamelCase : str = self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop UpperCamelCase : Tuple = time.time() try: UpperCamelCase : List[Any] = eval_loop( A_ , description="Prediction" , prediction_loss_only=True if compute_metrics is None else None , ignore_keys=A_ , metric_key_prefix=A_ , ) finally: UpperCamelCase : List[str] = compute_metrics UpperCamelCase : Union[str, Any] = self.args.eval_batch_size * self.args.world_size if F"""{metric_key_prefix}_jit_compilation_time""" in output.metrics: start_time += output.metrics[F"""{metric_key_prefix}_jit_compilation_time"""] output.metrics.update( speed_metrics( A_ , A_ , num_samples=output.num_samples , num_steps=math.ceil(output.num_samples / total_batch_size ) , ) ) if self.post_process_function is None or self.compute_metrics is None: return output UpperCamelCase : List[str] = self.post_process_function(A_ , A_ , output.predictions , "predict" ) UpperCamelCase : List[str] = self.compute_metrics(A_ ) # Prefix all keys with metric_key_prefix + '_' for key in list(metrics.keys() ): if not key.startswith(F"""{metric_key_prefix}_""" ): UpperCamelCase : str = metrics.pop(A_ ) metrics.update(output.metrics ) return PredictionOutput(predictions=predictions.predictions , label_ids=predictions.label_ids , metrics=A_ )
52
import unittest from transformers import LiltConfig, 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 ( LiltForQuestionAnswering, LiltForSequenceClassification, LiltForTokenClassification, LiltModel, ) from transformers.models.lilt.modeling_lilt import LILT_PRETRAINED_MODEL_ARCHIVE_LIST class A__ : def __init__( self , A_ , A_=13 , A_=7 , A_=True , A_=True , A_=True , A_=True , A_=99 , A_=24 , A_=2 , A_=6 , A_=37 , A_="gelu" , A_=0.1 , A_=0.1 , A_=512 , A_=16 , A_=2 , A_=0.02 , A_=3 , A_=None , A_=1000 , ): '''simple docstring''' UpperCamelCase : Union[str, Any] = parent UpperCamelCase : List[Any] = batch_size UpperCamelCase : Dict = seq_length UpperCamelCase : Tuple = is_training UpperCamelCase : Union[str, Any] = use_input_mask UpperCamelCase : Tuple = use_token_type_ids UpperCamelCase : Optional[Any] = use_labels UpperCamelCase : str = vocab_size UpperCamelCase : Optional[int] = hidden_size UpperCamelCase : Any = num_hidden_layers UpperCamelCase : Optional[Any] = num_attention_heads UpperCamelCase : Optional[Any] = intermediate_size UpperCamelCase : Optional[Any] = hidden_act UpperCamelCase : Union[str, Any] = hidden_dropout_prob UpperCamelCase : Union[str, Any] = attention_probs_dropout_prob UpperCamelCase : List[Any] = max_position_embeddings UpperCamelCase : str = type_vocab_size UpperCamelCase : Optional[int] = type_sequence_label_size UpperCamelCase : Dict = initializer_range UpperCamelCase : int = num_labels UpperCamelCase : Optional[int] = scope UpperCamelCase : int = range_bbox def __UpperCamelCase( self ): '''simple docstring''' UpperCamelCase : int = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) UpperCamelCase : Any = ids_tensor([self.batch_size, self.seq_length, 4] , self.range_bbox ) # Ensure that bbox is legal for i in range(bbox.shape[0] ): for j in range(bbox.shape[1] ): if bbox[i, j, 3] < bbox[i, j, 1]: UpperCamelCase : Union[str, Any] = bbox[i, j, 3] UpperCamelCase : int = bbox[i, j, 1] UpperCamelCase : int = t if bbox[i, j, 2] < bbox[i, j, 0]: UpperCamelCase : List[str] = bbox[i, j, 2] UpperCamelCase : Optional[int] = bbox[i, j, 0] UpperCamelCase : Optional[Any] = t UpperCamelCase : Dict = None if self.use_input_mask: UpperCamelCase : Optional[int] = ids_tensor([self.batch_size, self.seq_length] , vocab_size=2 ) UpperCamelCase : str = None if self.use_token_type_ids: UpperCamelCase : str = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) UpperCamelCase : Dict = None UpperCamelCase : int = None if self.use_labels: UpperCamelCase : List[Any] = ids_tensor([self.batch_size] , self.type_sequence_label_size ) UpperCamelCase : int = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) UpperCamelCase : List[Any] = self.get_config() return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels def __UpperCamelCase( self ): '''simple docstring''' return LiltConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , initializer_range=self.initializer_range , ) def __UpperCamelCase( self , A_ , A_ , A_ , A_ , A_ , A_ , A_ , ): '''simple docstring''' UpperCamelCase : Any = LiltModel(config=A_ ) model.to(A_ ) model.eval() UpperCamelCase : str = model(A_ , bbox=A_ , attention_mask=A_ , token_type_ids=A_ ) UpperCamelCase : Optional[int] = model(A_ , bbox=A_ , token_type_ids=A_ ) UpperCamelCase : Any = model(A_ , bbox=A_ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) self.parent.assertEqual(result.pooler_output.shape , (self.batch_size, self.hidden_size) ) def __UpperCamelCase( self , A_ , A_ , A_ , A_ , A_ , A_ , A_ , ): '''simple docstring''' UpperCamelCase : Any = self.num_labels UpperCamelCase : Dict = LiltForTokenClassification(config=A_ ) model.to(A_ ) model.eval() UpperCamelCase : Dict = model( A_ , bbox=A_ , attention_mask=A_ , token_type_ids=A_ , labels=A_ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def __UpperCamelCase( self , A_ , A_ , A_ , A_ , A_ , A_ , A_ , ): '''simple docstring''' UpperCamelCase : Dict = LiltForQuestionAnswering(config=A_ ) model.to(A_ ) model.eval() UpperCamelCase : List[str] = model( A_ , bbox=A_ , attention_mask=A_ , token_type_ids=A_ , start_positions=A_ , end_positions=A_ , ) self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) ) def __UpperCamelCase( self ): '''simple docstring''' UpperCamelCase : Any = self.prepare_config_and_inputs() ( ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ) : Tuple = config_and_inputs UpperCamelCase : Tuple = { "input_ids": input_ids, "bbox": bbox, "token_type_ids": token_type_ids, "attention_mask": input_mask, } return config, inputs_dict @require_torch class A__ ( __snake_case , __snake_case , __snake_case , unittest.TestCase ): _UpperCAmelCase :Union[str, Any] = ( ( LiltModel, LiltForSequenceClassification, LiltForTokenClassification, LiltForQuestionAnswering, ) if is_torch_available() else () ) _UpperCAmelCase :Optional[Any] = ( { 'feature-extraction': LiltModel, 'question-answering': LiltForQuestionAnswering, 'text-classification': LiltForSequenceClassification, 'token-classification': LiltForTokenClassification, 'zero-shot': LiltForSequenceClassification, } if is_torch_available() else {} ) _UpperCAmelCase :Dict = False _UpperCAmelCase :Union[str, Any] = False def __UpperCamelCase( self , A_ , A_ , A_ , A_ , A_ ): '''simple docstring''' return True def __UpperCamelCase( self ): '''simple docstring''' UpperCamelCase : Optional[int] = LiltModelTester(self ) UpperCamelCase : Optional[int] = ConfigTester(self , config_class=A_ , hidden_size=37 ) def __UpperCamelCase( self ): '''simple docstring''' self.config_tester.run_common_tests() def __UpperCamelCase( self ): '''simple docstring''' UpperCamelCase : Tuple = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*A_ ) def __UpperCamelCase( self ): '''simple docstring''' UpperCamelCase : Tuple = self.model_tester.prepare_config_and_inputs() for type in ["absolute", "relative_key", "relative_key_query"]: UpperCamelCase : Union[str, Any] = type self.model_tester.create_and_check_model(*A_ ) def __UpperCamelCase( self ): '''simple docstring''' UpperCamelCase : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*A_ ) def __UpperCamelCase( self ): '''simple docstring''' UpperCamelCase : List[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_question_answering(*A_ ) @slow def __UpperCamelCase( self ): '''simple docstring''' for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: UpperCamelCase : Dict = LiltModel.from_pretrained(A_ ) self.assertIsNotNone(A_ ) @require_torch @slow class A__ ( unittest.TestCase ): def __UpperCamelCase( self ): '''simple docstring''' UpperCamelCase : int = LiltModel.from_pretrained("SCUT-DLVCLab/lilt-roberta-en-base" ).to(A_ ) UpperCamelCase : Tuple = torch.tensor([[1, 2]] , device=A_ ) UpperCamelCase : List[str] = torch.tensor([[[1, 2, 3, 4], [5, 6, 7, 8]]] , device=A_ ) # forward pass with torch.no_grad(): UpperCamelCase : Optional[int] = model(input_ids=A_ , bbox=A_ ) UpperCamelCase : List[str] = torch.Size([1, 2, 768] ) UpperCamelCase : Any = torch.tensor( [[-0.06_53, 0.09_50, -0.00_61], [-0.05_45, 0.09_26, -0.03_24]] , device=A_ , ) self.assertTrue(outputs.last_hidden_state.shape , A_ ) self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :, :3] , A_ , atol=1e-3 ) )
52
1
"""simple docstring""" from typing import Any class a : """simple docstring""" def __init__( self: List[Any] , UpperCamelCase: Any ): """simple docstring""" A__ = data A__ = None class a : """simple docstring""" def __init__( self: List[str] ): """simple docstring""" A__ = None def UpperCamelCase ( self: Optional[Any] ): """simple docstring""" A__ = self.head while temp is not None: print(temp.data , end=""" """ ) A__ = temp.next print() def UpperCamelCase ( self: str , UpperCamelCase: Any ): """simple docstring""" A__ = Node(UpperCamelCase ) A__ = self.head A__ = new_node def UpperCamelCase ( self: Optional[int] , UpperCamelCase: Optional[int] , UpperCamelCase: Union[str, Any] ): """simple docstring""" if node_data_a == node_data_a: return else: A__ = self.head while node_a is not None and node_a.data != node_data_a: A__ = node_a.next A__ = self.head while node_a is not None and node_a.data != node_data_a: A__ = node_a.next if node_a is None or node_a is None: return A__ , A__ = node_a.data, node_a.data if __name__ == "__main__": SCREAMING_SNAKE_CASE_ : Tuple = LinkedList() for i in range(5, 0, -1): ll.push(i) ll.print_list() ll.swap_nodes(1, 4) print('After swapping') ll.print_list()
355
"""simple docstring""" def _snake_case ( UpperCAmelCase_ : int = 50 ): A__ = [1] * (length + 1) for row_length in range(length + 1 ): for tile_length in range(2 , 5 ): for tile_start in range(row_length - tile_length + 1 ): ways_number[row_length] += ways_number[ row_length - tile_start - tile_length ] return ways_number[length] if __name__ == "__main__": print(f"""{solution() = }""")
69
0
'''simple docstring''' import json import os from typing import Optional, Tuple import regex as re from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging _UpperCAmelCase : Optional[int] = logging.get_logger(__name__) _UpperCAmelCase : Optional[int] = { """vocab_file""": """vocab.json""", """merges_file""": """merges.txt""", } _UpperCAmelCase : Dict = { """vocab_file""": {"""ctrl""": """https://raw.githubusercontent.com/salesforce/ctrl/master/ctrl-vocab.json"""}, """merges_file""": {"""ctrl""": """https://raw.githubusercontent.com/salesforce/ctrl/master/ctrl-merges.txt"""}, } _UpperCAmelCase : Dict = { """ctrl""": 2_5_6, } _UpperCAmelCase : Union[str, Any] = { """Pregnancy""": 1_6_8_6_2_9, """Christianity""": 7_6_7_5, """Explain""": 1_0_6_4_2_3, """Fitness""": 6_3_4_4_0, """Saving""": 6_3_1_6_3, """Ask""": 2_7_1_7_1, """Ass""": 9_5_9_8_5, """Joke""": 1_6_3_5_0_9, """Questions""": 4_5_6_2_2, """Thoughts""": 4_9_6_0_5, """Retail""": 5_2_3_4_2, """Feminism""": 1_6_4_3_3_8, """Writing""": 1_1_9_9_2, """Atheism""": 1_9_2_2_6_3, """Netflix""": 4_8_6_1_6, """Computing""": 3_9_6_3_9, """Opinion""": 4_3_2_1_3, """Alone""": 4_4_9_6_7, """Funny""": 5_8_9_1_7, """Gaming""": 4_0_3_5_8, """Human""": 4_0_8_8, """India""": 1_3_3_1, """Joker""": 7_7_1_3_8, """Diet""": 3_6_2_0_6, """Legal""": 1_1_8_5_9, """Norman""": 4_9_3_9, """Tip""": 7_2_6_8_9, """Weight""": 5_2_3_4_3, """Movies""": 4_6_2_7_3, """Running""": 2_3_4_2_5, """Science""": 2_0_9_0, """Horror""": 3_7_7_9_3, """Confession""": 6_0_5_7_2, """Finance""": 1_2_2_5_0, """Politics""": 1_6_3_6_0, """Scary""": 1_9_1_9_8_5, """Support""": 1_2_6_5_4, """Technologies""": 3_2_5_1_6, """Teenage""": 6_6_1_6_0, """Event""": 3_2_7_6_9, """Learned""": 6_7_4_6_0, """Notion""": 1_8_2_7_7_0, """Wikipedia""": 3_7_5_8_3, """Books""": 6_6_6_5, """Extract""": 7_6_0_5_0, """Confessions""": 1_0_2_7_0_1, """Conspiracy""": 7_5_9_3_2, """Links""": 6_3_6_7_4, """Narcissus""": 1_5_0_4_2_5, """Relationship""": 5_4_7_6_6, """Relationships""": 1_3_4_7_9_6, """Reviews""": 4_1_6_7_1, """News""": 4_2_5_6, """Translation""": 2_6_8_2_0, """multilingual""": 1_2_8_4_0_6, } def __magic_name__( lowerCamelCase): __lowerCAmelCase = set() __lowerCAmelCase = word[0] for char in word[1:]: pairs.add((prev_char, char)) __lowerCAmelCase = char __lowerCAmelCase = set(lowerCamelCase) return pairs class a__ ( __A ): """simple docstring""" __UpperCamelCase : Tuple = VOCAB_FILES_NAMES __UpperCamelCase : Optional[Any] = PRETRAINED_VOCAB_FILES_MAP __UpperCamelCase : str = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES __UpperCamelCase : List[Any] = CONTROL_CODES def __init__(self , __lowercase , __lowercase , __lowercase="<unk>" , **__lowercase ): super().__init__(unk_token=__lowercase , **__lowercase ) with open(__lowercase , encoding='''utf-8''' ) as vocab_handle: __lowerCAmelCase = json.load(__lowercase ) __lowerCAmelCase = {v: k for k, v in self.encoder.items()} with open(__lowercase , encoding='''utf-8''' ) as merges_handle: __lowerCAmelCase = merges_handle.read().split('''\n''' )[1:-1] __lowerCAmelCase = [tuple(merge.split() ) for merge in merges] __lowerCAmelCase = dict(zip(__lowercase , range(len(__lowercase ) ) ) ) __lowerCAmelCase = {} @property def _snake_case (self ): return len(self.encoder ) def _snake_case (self ): return dict(self.encoder , **self.added_tokens_encoder ) def _snake_case (self , __lowercase ): if token in self.cache: return self.cache[token] __lowerCAmelCase = tuple(__lowercase ) __lowerCAmelCase = tuple(list(word[:-1] ) + [word[-1] + '''</w>'''] ) __lowerCAmelCase = get_pairs(__lowercase ) if not pairs: return token while True: __lowerCAmelCase = min(__lowercase , key=lambda __lowercase : self.bpe_ranks.get(__lowercase , float('''inf''' ) ) ) if bigram not in self.bpe_ranks: break __lowerCAmelCase , __lowerCAmelCase = bigram __lowerCAmelCase = [] __lowerCAmelCase = 0 while i < len(__lowercase ): try: __lowerCAmelCase = word.index(__lowercase , __lowercase ) except ValueError: new_word.extend(word[i:] ) break else: new_word.extend(word[i:j] ) __lowerCAmelCase = j if word[i] == first and i < len(__lowercase ) - 1 and word[i + 1] == second: new_word.append(first + second ) i += 2 else: new_word.append(word[i] ) i += 1 __lowerCAmelCase = tuple(__lowercase ) __lowerCAmelCase = new_word if len(__lowercase ) == 1: break else: __lowerCAmelCase = get_pairs(__lowercase ) __lowerCAmelCase = '''@@ '''.join(__lowercase ) __lowerCAmelCase = word[:-4] __lowerCAmelCase = word return word def _snake_case (self , __lowercase ): __lowerCAmelCase = [] __lowerCAmelCase = re.findall(R'''\S+\n?''' , __lowercase ) for token in words: split_tokens.extend(list(self.bpe(__lowercase ).split(''' ''' ) ) ) return split_tokens def _snake_case (self , __lowercase ): return self.encoder.get(__lowercase , self.encoder.get(self.unk_token ) ) def _snake_case (self , __lowercase ): return self.decoder.get(__lowercase , self.unk_token ) def _snake_case (self , __lowercase ): __lowerCAmelCase = ''' '''.join(__lowercase ).replace('''@@ ''' , '''''' ).strip() return out_string def _snake_case (self , __lowercase , __lowercase = None ): if not os.path.isdir(__lowercase ): logger.error(F"""Vocabulary path ({save_directory}) should be a directory""" ) return __lowerCAmelCase = os.path.join( __lowercase , (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file'''] ) __lowerCAmelCase = os.path.join( __lowercase , (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''merges_file'''] ) with open(__lowercase , '''w''' , encoding='''utf-8''' ) as f: f.write(json.dumps(self.encoder , indent=2 , sort_keys=__lowercase , ensure_ascii=__lowercase ) + '''\n''' ) __lowerCAmelCase = 0 with open(__lowercase , '''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 __lowercase : 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!''' ) __lowerCAmelCase = token_index writer.write(''' '''.join(__lowercase ) + '''\n''' ) index += 1 return vocab_file, merge_file # def decode(self, token_ids, skip_special_tokens=False, clean_up_tokenization_spaces=True): # filtered_tokens = ' '.join(self.convert_ids_to_tokens(token_ids, skip_special_tokens=skip_special_tokens)) # tokens_generated_so_far = re.sub('(@@ )', '', string=filtered_tokens) # tokens_generated_so_far = re.sub('(@@ ?$)', '', string=tokens_generated_so_far) # return ''.join(tokens_generated_so_far)
174
'''simple docstring''' import argparse import os import re _UpperCAmelCase : Tuple = """src/transformers""" # Pattern that looks at the indentation in a line. _UpperCAmelCase : Any = re.compile(r"""^(\s*)\S""") # Pattern that matches `"key":" and puts `key` in group 0. _UpperCAmelCase : List[Any] = re.compile(r"""^\s*\"([^\"]+)\":""") # Pattern that matches `_import_structure["key"]` and puts `key` in group 0. _UpperCAmelCase : Optional[int] = re.compile(r"""^\s*_import_structure\[\"([^\"]+)\"\]""") # Pattern that matches `"key",` and puts `key` in group 0. _UpperCAmelCase : Tuple = re.compile(r"""^\s*\"([^\"]+)\",\s*$""") # Pattern that matches any `[stuff]` and puts `stuff` in group 0. _UpperCAmelCase : Optional[int] = re.compile(r"""\[([^\]]+)\]""") def __magic_name__( lowerCamelCase): __lowerCAmelCase = _re_indent.search(lowerCamelCase) return "" if search is None else search.groups()[0] def __magic_name__( lowerCamelCase, lowerCamelCase="", lowerCamelCase=None, lowerCamelCase=None): __lowerCAmelCase = 0 __lowerCAmelCase = code.split('''\n''') if start_prompt is not None: while not lines[index].startswith(lowerCamelCase): index += 1 __lowerCAmelCase = ['''\n'''.join(lines[:index])] else: __lowerCAmelCase = [] # We split into blocks until we get to the `end_prompt` (or the end of the block). __lowerCAmelCase = [lines[index]] index += 1 while index < len(lowerCamelCase) and (end_prompt is None or not lines[index].startswith(lowerCamelCase)): if len(lines[index]) > 0 and get_indent(lines[index]) == indent_level: if len(lowerCamelCase) > 0 and get_indent(current_block[-1]).startswith(indent_level + ''' '''): current_block.append(lines[index]) blocks.append('''\n'''.join(lowerCamelCase)) if index < len(lowerCamelCase) - 1: __lowerCAmelCase = [lines[index + 1]] index += 1 else: __lowerCAmelCase = [] else: blocks.append('''\n'''.join(lowerCamelCase)) __lowerCAmelCase = [lines[index]] else: current_block.append(lines[index]) index += 1 # Adds current block if it's nonempty. if len(lowerCamelCase) > 0: blocks.append('''\n'''.join(lowerCamelCase)) # Add final block after end_prompt if provided. if end_prompt is not None and index < len(lowerCamelCase): blocks.append('''\n'''.join(lines[index:])) return blocks def __magic_name__( lowerCamelCase): def _inner(lowerCamelCase): return key(lowerCamelCase).lower().replace('''_''', '''''') return _inner def __magic_name__( lowerCamelCase, lowerCamelCase=None): # If no key is provided, we use a noop. def noop(lowerCamelCase): return x if key is None: __lowerCAmelCase = noop # Constants are all uppercase, they go first. __lowerCAmelCase = [obj for obj in objects if key(lowerCamelCase).isupper()] # Classes are not all uppercase but start with a capital, they go second. __lowerCAmelCase = [obj for obj in objects if key(lowerCamelCase)[0].isupper() and not key(lowerCamelCase).isupper()] # Functions begin with a lowercase, they go last. __lowerCAmelCase = [obj for obj in objects if not key(lowerCamelCase)[0].isupper()] __lowerCAmelCase = ignore_underscore(lowerCamelCase) return sorted(lowerCamelCase, key=lowerCamelCase) + sorted(lowerCamelCase, key=lowerCamelCase) + sorted(lowerCamelCase, key=lowerCamelCase) def __magic_name__( lowerCamelCase): # This inner function sort imports between [ ]. def _replace(lowerCamelCase): __lowerCAmelCase = match.groups()[0] if "," not in imports: return F"""[{imports}]""" __lowerCAmelCase = [part.strip().replace('''"''', '''''') for part in imports.split(''',''')] # We will have a final empty element if the line finished with a comma. if len(keys[-1]) == 0: __lowerCAmelCase = keys[:-1] return "[" + ", ".join([F"""\"{k}\"""" for k in sort_objects(lowerCamelCase)]) + "]" __lowerCAmelCase = import_statement.split('''\n''') if len(lowerCamelCase) > 3: # Here we have to sort internal imports that are on several lines (one per name): # key: [ # "object1", # "object2", # ... # ] # We may have to ignore one or two lines on each side. __lowerCAmelCase = 2 if lines[1].strip() == '''[''' else 1 __lowerCAmelCase = [(i, _re_strip_line.search(lowerCamelCase).groups()[0]) for i, line in enumerate(lines[idx:-idx])] __lowerCAmelCase = sort_objects(lowerCamelCase, key=lambda lowerCamelCase: x[1]) __lowerCAmelCase = [lines[x[0] + idx] for x in sorted_indices] return "\n".join(lines[:idx] + sorted_lines + lines[-idx:]) elif len(lowerCamelCase) == 3: # Here we have to sort internal imports that are on one separate line: # key: [ # "object1", "object2", ... # ] if _re_bracket_content.search(lines[1]) is not None: __lowerCAmelCase = _re_bracket_content.sub(_replace, lines[1]) else: __lowerCAmelCase = [part.strip().replace('''"''', '''''') for part in lines[1].split(''',''')] # We will have a final empty element if the line finished with a comma. if len(keys[-1]) == 0: __lowerCAmelCase = keys[:-1] __lowerCAmelCase = get_indent(lines[1]) + ''', '''.join([F"""\"{k}\"""" for k in sort_objects(lowerCamelCase)]) return "\n".join(lowerCamelCase) else: # Finally we have to deal with imports fitting on one line __lowerCAmelCase = _re_bracket_content.sub(_replace, lowerCamelCase) return import_statement def __magic_name__( lowerCamelCase, lowerCamelCase=True): with open(lowerCamelCase, encoding='''utf-8''') as f: __lowerCAmelCase = f.read() if "_import_structure" not in code: return # Blocks of indent level 0 __lowerCAmelCase = split_code_in_indented_blocks( lowerCamelCase, start_prompt='''_import_structure = {''', end_prompt='''if TYPE_CHECKING:''') # We ignore block 0 (everything untils start_prompt) and the last block (everything after end_prompt). for block_idx in range(1, len(lowerCamelCase) - 1): # Check if the block contains some `_import_structure`s thingy to sort. __lowerCAmelCase = main_blocks[block_idx] __lowerCAmelCase = block.split('''\n''') # Get to the start of the imports. __lowerCAmelCase = 0 while line_idx < len(lowerCamelCase) and "_import_structure" not in block_lines[line_idx]: # Skip dummy import blocks if "import dummy" in block_lines[line_idx]: __lowerCAmelCase = len(lowerCamelCase) else: line_idx += 1 if line_idx >= len(lowerCamelCase): continue # Ignore beginning and last line: they don't contain anything. __lowerCAmelCase = '''\n'''.join(block_lines[line_idx:-1]) __lowerCAmelCase = get_indent(block_lines[1]) # Slit the internal block into blocks of indent level 1. __lowerCAmelCase = split_code_in_indented_blocks(lowerCamelCase, indent_level=lowerCamelCase) # We have two categories of import key: list or _import_structure[key].append/extend __lowerCAmelCase = _re_direct_key if '''_import_structure = {''' in block_lines[0] else _re_indirect_key # Grab the keys, but there is a trap: some lines are empty or just comments. __lowerCAmelCase = [(pattern.search(lowerCamelCase).groups()[0] if pattern.search(lowerCamelCase) is not None else None) for b in internal_blocks] # We only sort the lines with a key. __lowerCAmelCase = [(i, key) for i, key in enumerate(lowerCamelCase) if key is not None] __lowerCAmelCase = [x[0] for x in sorted(lowerCamelCase, key=lambda lowerCamelCase: x[1])] # We reorder the blocks by leaving empty lines/comments as they were and reorder the rest. __lowerCAmelCase = 0 __lowerCAmelCase = [] for i in range(len(lowerCamelCase)): if keys[i] is None: reorderded_blocks.append(internal_blocks[i]) else: __lowerCAmelCase = sort_objects_in_import(internal_blocks[sorted_indices[count]]) reorderded_blocks.append(lowerCamelCase) count += 1 # And we put our main block back together with its first and last line. __lowerCAmelCase = '''\n'''.join(block_lines[:line_idx] + reorderded_blocks + [block_lines[-1]]) if code != "\n".join(lowerCamelCase): if check_only: return True else: print(F"""Overwriting {file}.""") with open(lowerCamelCase, '''w''', encoding='''utf-8''') as f: f.write('''\n'''.join(lowerCamelCase)) def __magic_name__( lowerCamelCase=True): __lowerCAmelCase = [] for root, _, files in os.walk(lowerCamelCase): if "__init__.py" in files: __lowerCAmelCase = sort_imports(os.path.join(lowerCamelCase, '''__init__.py'''), check_only=lowerCamelCase) if result: __lowerCAmelCase = [os.path.join(lowerCamelCase, '''__init__.py''')] if len(lowerCamelCase) > 0: raise ValueError(F"""Would overwrite {len(lowerCamelCase)} files, run `make style`.""") if __name__ == "__main__": _UpperCAmelCase : str = argparse.ArgumentParser() parser.add_argument("""--check_only""", action="""store_true""", help="""Whether to only check or fix style.""") _UpperCAmelCase : Optional[int] = parser.parse_args() sort_imports_in_all_inits(check_only=args.check_only)
174
1
"""simple docstring""" import warnings from ...utils import logging from .image_processing_layoutlmva import LayoutLMvaImageProcessor __UpperCamelCase = logging.get_logger(__name__) class lowerCAmelCase ( lowerCamelCase_ ): '''simple docstring''' def __init__( self , *lowerCAmelCase__ , **lowerCAmelCase__ ) -> None: warnings.warn( 'The class LayoutLMv2FeatureExtractor is deprecated and will be removed in version 5 of Transformers.' ' Please use LayoutLMv2ImageProcessor instead.' , lowerCAmelCase__ , ) super().__init__(*lowerCAmelCase__ , **lowerCAmelCase__ )
371
"""simple docstring""" import warnings from typing import List, Optional, Union from ...image_utils import ImageInput from ...processing_utils import ProcessorMixin from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy from ...utils import TensorType class lowerCAmelCase ( lowerCamelCase_ ): '''simple docstring''' SCREAMING_SNAKE_CASE_ : int = ["""image_processor""", """tokenizer"""] SCREAMING_SNAKE_CASE_ : Any = """FlavaImageProcessor""" SCREAMING_SNAKE_CASE_ : List[str] = ("""BertTokenizer""", """BertTokenizerFast""") def __init__( self , lowerCAmelCase__=None , lowerCAmelCase__=None , **lowerCAmelCase__ ) -> List[str]: SCREAMING_SNAKE_CASE = None if "feature_extractor" in kwargs: warnings.warn( 'The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`' ' instead.' , lowerCAmelCase__ , ) SCREAMING_SNAKE_CASE = kwargs.pop('feature_extractor' ) SCREAMING_SNAKE_CASE = image_processor if image_processor is not None else feature_extractor if image_processor is None: raise ValueError('You need to specify an `image_processor`.' ) if tokenizer is None: raise ValueError('You need to specify a `tokenizer`.' ) super().__init__(lowerCAmelCase__ , lowerCAmelCase__ ) SCREAMING_SNAKE_CASE = self.image_processor def __call__( self , lowerCAmelCase__ = None , lowerCAmelCase__ = None , lowerCAmelCase__ = True , lowerCAmelCase__ = False , lowerCAmelCase__ = False , lowerCAmelCase__ = None , lowerCAmelCase__ = 0 , lowerCAmelCase__ = None , lowerCAmelCase__ = None , lowerCAmelCase__ = None , lowerCAmelCase__ = None , lowerCAmelCase__ = None , lowerCAmelCase__ = False , lowerCAmelCase__ = False , lowerCAmelCase__ = False , lowerCAmelCase__ = False , lowerCAmelCase__ = True , lowerCAmelCase__ = None , **lowerCAmelCase__ , ) -> List[str]: if text is None and images is None: raise ValueError('You have to specify either text or images. Both cannot be none.' ) if text is not None: SCREAMING_SNAKE_CASE = self.tokenizer( text=lowerCAmelCase__ , add_special_tokens=lowerCAmelCase__ , padding=lowerCAmelCase__ , truncation=lowerCAmelCase__ , max_length=lowerCAmelCase__ , stride=lowerCAmelCase__ , pad_to_multiple_of=lowerCAmelCase__ , return_token_type_ids=lowerCAmelCase__ , return_attention_mask=lowerCAmelCase__ , return_overflowing_tokens=lowerCAmelCase__ , return_special_tokens_mask=lowerCAmelCase__ , return_offsets_mapping=lowerCAmelCase__ , return_length=lowerCAmelCase__ , verbose=lowerCAmelCase__ , return_tensors=lowerCAmelCase__ , **lowerCAmelCase__ , ) if images is not None: SCREAMING_SNAKE_CASE = self.image_processor( lowerCAmelCase__ , return_image_mask=lowerCAmelCase__ , return_codebook_pixels=lowerCAmelCase__ , return_tensors=lowerCAmelCase__ , **lowerCAmelCase__ , ) if text is not None and images is not None: encoding.update(lowerCAmelCase__ ) return encoding elif text is not None: return encoding else: return BatchEncoding(data=dict(**lowerCAmelCase__ ) , tensor_type=lowerCAmelCase__ ) def __A ( self , *lowerCAmelCase__ , **lowerCAmelCase__ ) -> List[str]: return self.tokenizer.batch_decode(*lowerCAmelCase__ , **lowerCAmelCase__ ) def __A ( self , *lowerCAmelCase__ , **lowerCAmelCase__ ) -> Tuple: return self.tokenizer.decode(*lowerCAmelCase__ , **lowerCAmelCase__ ) @property def __A ( self ) -> Dict: SCREAMING_SNAKE_CASE = self.tokenizer.model_input_names SCREAMING_SNAKE_CASE = self.image_processor.model_input_names return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names ) ) @property def __A ( self ) -> str: warnings.warn( '`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.' , lowerCAmelCase__ , ) return self.image_processor_class @property def __A ( self ) -> Dict: warnings.warn( '`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.' , lowerCAmelCase__ , ) return self.image_processor
38
0
"""simple docstring""" import os import tempfile from functools import partial from unittest import TestCase from unittest.mock import patch import numpy as np import pytest from datasets.arrow_dataset import Dataset from datasets.search import ElasticSearchIndex, FaissIndex, MissingIndex from .utils import require_elasticsearch, require_faiss lowercase__ = pytest.mark.integration @require_faiss class lowerCAmelCase__ ( lowercase ): '''simple docstring''' def A_ ( self ): _lowerCamelCase : int = Dataset.from_dict({'filename': ['my_name-train' + '_' + str(lowercase ) for x in np.arange(30 ).tolist()]} ) return dset def A_ ( self ): import faiss _lowerCamelCase : Dataset = self._create_dummy_dataset() _lowerCamelCase : str = dset.map( lambda lowercase , lowercase : {"vecs": i * np.ones(5 , dtype=np.floataa )} , with_indices=lowercase , keep_in_memory=lowercase ) _lowerCamelCase : Optional[Any] = dset.add_faiss_index('vecs' , batch_size=100 , metric_type=faiss.METRIC_INNER_PRODUCT ) _lowerCamelCase, _lowerCamelCase : int = 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 A_ ( self ): import faiss _lowerCamelCase : Dataset = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name='vecs' , batch_size=100 , metric_type=faiss.METRIC_INNER_PRODUCT , ) _lowerCamelCase, _lowerCamelCase : Optional[int] = dset.get_nearest_examples('vecs' , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples['filename'][0] , 'my_name-train_29' ) def A_ ( self ): import faiss _lowerCamelCase : Dataset = 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 : Dict = dset.get_nearest_examples('vecs2' , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples['filename'][0] , 'my_name-train_29' ) def A_ ( self ): _lowerCamelCase : Dataset = 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 A_ ( self ): from elasticsearch import Elasticsearch _lowerCamelCase : Dataset = 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 : Tuple = {'acknowledged': True} mocked_bulk.return_value([(True, None)] * 30 ) _lowerCamelCase : List[Any] = {'hits': {'hits': [{'_score': 1, '_id': 29}]}} _lowerCamelCase : Optional[int] = Elasticsearch() dset.add_elasticsearch_index('filename' , es_client=lowercase ) _lowerCamelCase, _lowerCamelCase : Union[str, Any] = dset.get_nearest_examples('filename' , 'my_name-train_29' ) self.assertEqual(examples['filename'][0] , 'my_name-train_29' ) @require_faiss class lowerCAmelCase__ ( lowercase ): '''simple docstring''' def A_ ( self ): import faiss _lowerCamelCase : str = 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 : Dict = np.zeros(5 , dtype=np.floataa ) _lowerCamelCase : Dict = 1 _lowerCamelCase, _lowerCamelCase : int = 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 : Union[str, Any] = np.eye(5 , dtype=np.floataa )[::-1] _lowerCamelCase, _lowerCamelCase : str = index.search_batch(lowercase ) self.assertRaises(lowercase , index.search_batch , queries[0] ) _lowerCamelCase : List[str] = [scores[0] for scores in total_scores] _lowerCamelCase : List[Any] = [indices[0] for indices in total_indices] self.assertGreater(np.min(lowercase ) , 0 ) self.assertListEqual([4, 3, 2, 1, 0] , lowercase ) def A_ ( self ): import faiss _lowerCamelCase : Tuple = FaissIndex(string_factory='Flat' ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexFlat ) _lowerCamelCase : int = 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 : List[Any] = FaissIndex(string_factory='Flat' , custom_index=faiss.IndexFlat(5 ) ) def A_ ( self ): import faiss _lowerCamelCase : Dict = faiss.IndexFlat(5 ) _lowerCamelCase : Union[str, Any] = FaissIndex(custom_index=lowercase ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexFlat ) def A_ ( self ): import faiss _lowerCamelCase : Tuple = 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 : Union[str, Any] = FaissIndex.load(tmp_file.name ) os.unlink(tmp_file.name ) _lowerCamelCase : Tuple = np.zeros(5 , dtype=np.floataa ) _lowerCamelCase : Optional[int] = 1 _lowerCamelCase, _lowerCamelCase : Tuple = index.search(lowercase ) self.assertGreater(scores[0] , 0 ) self.assertEqual(indices[0] , 1 ) @require_faiss def _snake_case ( lowercase__ ): import faiss _lowerCamelCase : str = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) _lowerCamelCase : Dict = 'index.faiss' _lowerCamelCase : Optional[int] = f'''mock://{index_name}''' index.save(lowercase__ , storage_options=mockfs.storage_options ) _lowerCamelCase : Dict = FaissIndex.load(lowercase__ , storage_options=mockfs.storage_options ) _lowerCamelCase : Union[str, Any] = np.zeros(5 , dtype=np.floataa ) _lowerCamelCase : Any = 1 _lowerCamelCase, _lowerCamelCase : List[Any] = index.search(lowercase__ ) assert scores[0] > 0 assert indices[0] == 1 @require_elasticsearch class lowerCAmelCase__ ( lowercase ): '''simple docstring''' def A_ ( self ): 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 : Tuple = Elasticsearch() _lowerCamelCase : List[Any] = {'acknowledged': True} _lowerCamelCase : Optional[Any] = ElasticSearchIndex(es_client=lowercase ) mocked_bulk.return_value([(True, None)] * 3 ) index.add_documents(['foo', 'bar', 'foobar'] ) # single query _lowerCamelCase : Optional[Any] = 'foo' _lowerCamelCase : List[Any] = {'hits': {'hits': [{'_score': 1, '_id': 0}]}} _lowerCamelCase, _lowerCamelCase : List[Any] = index.search(lowercase ) self.assertEqual(scores[0] , 1 ) self.assertEqual(indices[0] , 0 ) # single query with timeout _lowerCamelCase : List[str] = 'foo' _lowerCamelCase : Union[str, Any] = {'hits': {'hits': [{'_score': 1, '_id': 0}]}} _lowerCamelCase, _lowerCamelCase : str = index.search(lowercase , request_timeout=30 ) self.assertEqual(scores[0] , 1 ) self.assertEqual(indices[0] , 0 ) # batched queries _lowerCamelCase : Dict = ['foo', 'bar', 'foobar'] _lowerCamelCase : str = {'hits': {'hits': [{'_score': 1, '_id': 1}]}} _lowerCamelCase, _lowerCamelCase : List[str] = index.search_batch(lowercase ) _lowerCamelCase : Union[str, Any] = [scores[0] for scores in total_scores] _lowerCamelCase : Tuple = [indices[0] for indices in total_indices] self.assertGreater(np.min(lowercase ) , 0 ) self.assertListEqual([1, 1, 1] , lowercase ) # batched queries with timeout _lowerCamelCase : Optional[int] = ['foo', 'bar', 'foobar'] _lowerCamelCase : str = {'hits': {'hits': [{'_score': 1, '_id': 1}]}} _lowerCamelCase, _lowerCamelCase : Union[str, Any] = index.search_batch(lowercase , request_timeout=30 ) _lowerCamelCase : Optional[int] = [scores[0] for scores in total_scores] _lowerCamelCase : List[str] = [indices[0] for indices in total_indices] self.assertGreater(np.min(lowercase ) , 0 ) self.assertListEqual([1, 1, 1] , lowercase )
96
"""simple docstring""" from __future__ import annotations _a : List[Any]= [] def __UpperCAmelCase ( UpperCAmelCase_ : list[list[int]] , UpperCAmelCase_ : int , UpperCAmelCase_ : int ) -> bool: '''simple docstring''' for i in range(len(UpperCAmelCase_ ) ): if board[row][i] == 1: return False for i in range(len(UpperCAmelCase_ ) ): if board[i][column] == 1: return False for i, j in zip(range(UpperCAmelCase_ , -1 , -1 ) , range(UpperCAmelCase_ , -1 , -1 ) ): if board[i][j] == 1: return False for i, j in zip(range(UpperCAmelCase_ , -1 , -1 ) , range(UpperCAmelCase_ , len(UpperCAmelCase_ ) ) ): if board[i][j] == 1: return False return True def __UpperCAmelCase ( UpperCAmelCase_ : list[list[int]] , UpperCAmelCase_ : int ) -> bool: '''simple docstring''' if row >= len(UpperCAmelCase_ ): solution.append(UpperCAmelCase_ ) printboard(UpperCAmelCase_ ) print() return True for i in range(len(UpperCAmelCase_ ) ): if is_safe(UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ ): __snake_case : Any = 1 solve(UpperCAmelCase_ , row + 1 ) __snake_case : List[str] = 0 return False def __UpperCAmelCase ( UpperCAmelCase_ : list[list[int]] ) -> None: '''simple docstring''' for i in range(len(UpperCAmelCase_ ) ): for j in range(len(UpperCAmelCase_ ) ): if board[i][j] == 1: print('Q' , end=' ' ) else: print('.' , end=' ' ) print() # n=int(input("The no. of queens")) _a : Optional[int]= 8 _a : List[str]= [[0 for i in range(n)] for j in range(n)] solve(board, 0) print("The total no. of solutions are :", len(solution))
172
0
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available SCREAMING_SNAKE_CASE : Optional[Any] = { """configuration_instructblip""": [ """INSTRUCTBLIP_PRETRAINED_CONFIG_ARCHIVE_MAP""", """InstructBlipConfig""", """InstructBlipQFormerConfig""", """InstructBlipVisionConfig""", ], """processing_instructblip""": ["""InstructBlipProcessor"""], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : List[str] = [ """INSTRUCTBLIP_PRETRAINED_MODEL_ARCHIVE_LIST""", """InstructBlipQFormerModel""", """InstructBlipPreTrainedModel""", """InstructBlipForConditionalGeneration""", """InstructBlipVisionModel""", ] if TYPE_CHECKING: from .configuration_instructblip import ( INSTRUCTBLIP_PRETRAINED_CONFIG_ARCHIVE_MAP, InstructBlipConfig, InstructBlipQFormerConfig, InstructBlipVisionConfig, ) from .processing_instructblip import InstructBlipProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_instructblip import ( INSTRUCTBLIP_PRETRAINED_MODEL_ARCHIVE_LIST, InstructBlipForConditionalGeneration, InstructBlipPreTrainedModel, InstructBlipQFormerModel, InstructBlipVisionModel, ) else: import sys SCREAMING_SNAKE_CASE : Dict = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
357
"""simple docstring""" import argparse import tensorflow as tf import torch from transformers import BertConfig, BertForMaskedLM from transformers.models.bert.modeling_bert import ( BertIntermediate, BertLayer, BertOutput, BertPooler, BertSelfAttention, BertSelfOutput, ) from transformers.utils import logging logging.set_verbosity_info() def lowercase ( _snake_case : str , _snake_case : str , _snake_case : str ) ->List[Any]: """simple docstring""" def get_masked_lm_array(_snake_case : str ): __snake_case : int = f"""masked_lm/{name}/.ATTRIBUTES/VARIABLE_VALUE""" __snake_case : str = tf.train.load_variable(_snake_case , _snake_case ) if "kernel" in name: __snake_case : Any = array.transpose() return torch.from_numpy(_snake_case ) def get_encoder_array(_snake_case : str ): __snake_case : List[str] = f"""encoder/{name}/.ATTRIBUTES/VARIABLE_VALUE""" __snake_case : Union[str, Any] = tf.train.load_variable(_snake_case , _snake_case ) if "kernel" in name: __snake_case : Optional[int] = array.transpose() return torch.from_numpy(_snake_case ) def get_encoder_layer_array(_snake_case : int , _snake_case : str ): __snake_case : str = f"""encoder/_transformer_layers/{layer_index}/{name}/.ATTRIBUTES/VARIABLE_VALUE""" __snake_case : Optional[int] = tf.train.load_variable(_snake_case , _snake_case ) if "kernel" in name: __snake_case : Optional[Any] = array.transpose() return torch.from_numpy(_snake_case ) def get_encoder_attention_layer_array(_snake_case : int , _snake_case : str , _snake_case : str ): __snake_case : Any = f"""encoder/_transformer_layers/{layer_index}/_attention_layer/{name}/.ATTRIBUTES/VARIABLE_VALUE""" __snake_case : Dict = tf.train.load_variable(_snake_case , _snake_case ) __snake_case : int = array.reshape(_snake_case ) if "kernel" in name: __snake_case : Optional[int] = array.transpose() return torch.from_numpy(_snake_case ) print(f"""Loading model based on config from {config_path}...""" ) __snake_case : Optional[Any] = BertConfig.from_json_file(_snake_case ) __snake_case : Dict = BertForMaskedLM(_snake_case ) # Layers for layer_index in range(0 , config.num_hidden_layers ): __snake_case : BertLayer = model.bert.encoder.layer[layer_index] # Self-attention __snake_case : BertSelfAttention = layer.attention.self __snake_case : int = get_encoder_attention_layer_array( _snake_case , '''_query_dense/kernel''' , self_attn.query.weight.data.shape ) __snake_case : str = get_encoder_attention_layer_array( _snake_case , '''_query_dense/bias''' , self_attn.query.bias.data.shape ) __snake_case : str = get_encoder_attention_layer_array( _snake_case , '''_key_dense/kernel''' , self_attn.key.weight.data.shape ) __snake_case : List[Any] = get_encoder_attention_layer_array( _snake_case , '''_key_dense/bias''' , self_attn.key.bias.data.shape ) __snake_case : Tuple = get_encoder_attention_layer_array( _snake_case , '''_value_dense/kernel''' , self_attn.value.weight.data.shape ) __snake_case : Union[str, Any] = get_encoder_attention_layer_array( _snake_case , '''_value_dense/bias''' , self_attn.value.bias.data.shape ) # Self-attention Output __snake_case : BertSelfOutput = layer.attention.output __snake_case : Dict = get_encoder_attention_layer_array( _snake_case , '''_output_dense/kernel''' , self_output.dense.weight.data.shape ) __snake_case : Tuple = get_encoder_attention_layer_array( _snake_case , '''_output_dense/bias''' , self_output.dense.bias.data.shape ) __snake_case : str = get_encoder_layer_array(_snake_case , '''_attention_layer_norm/gamma''' ) __snake_case : Any = get_encoder_layer_array(_snake_case , '''_attention_layer_norm/beta''' ) # Intermediate __snake_case : BertIntermediate = layer.intermediate __snake_case : int = get_encoder_layer_array(_snake_case , '''_intermediate_dense/kernel''' ) __snake_case : int = get_encoder_layer_array(_snake_case , '''_intermediate_dense/bias''' ) # Output __snake_case : BertOutput = layer.output __snake_case : List[str] = get_encoder_layer_array(_snake_case , '''_output_dense/kernel''' ) __snake_case : Dict = get_encoder_layer_array(_snake_case , '''_output_dense/bias''' ) __snake_case : List[str] = get_encoder_layer_array(_snake_case , '''_output_layer_norm/gamma''' ) __snake_case : Union[str, Any] = get_encoder_layer_array(_snake_case , '''_output_layer_norm/beta''' ) # Embeddings __snake_case : Optional[int] = get_encoder_array('''_position_embedding_layer/embeddings''' ) __snake_case : str = get_encoder_array('''_type_embedding_layer/embeddings''' ) __snake_case : int = get_encoder_array('''_embedding_norm_layer/gamma''' ) __snake_case : Tuple = get_encoder_array('''_embedding_norm_layer/beta''' ) # LM Head __snake_case : Optional[Any] = model.cls.predictions.transform __snake_case : Dict = get_masked_lm_array('''dense/kernel''' ) __snake_case : Union[str, Any] = get_masked_lm_array('''dense/bias''' ) __snake_case : str = get_masked_lm_array('''layer_norm/gamma''' ) __snake_case : Tuple = get_masked_lm_array('''layer_norm/beta''' ) __snake_case : Tuple = get_masked_lm_array('''embedding_table''' ) # Pooling __snake_case : Optional[Any] = BertPooler(config=_snake_case ) __snake_case : BertPooler = get_encoder_array('''_pooler_layer/kernel''' ) __snake_case : BertPooler = get_encoder_array('''_pooler_layer/bias''' ) # Export final model model.save_pretrained(_snake_case ) # Integration test - should load without any errors ;) __snake_case : Dict = BertForMaskedLM.from_pretrained(_snake_case ) print(new_model.eval() ) print('''Model conversion was done sucessfully!''' ) if __name__ == "__main__": SCREAMING_SNAKE_CASE : int = argparse.ArgumentParser() parser.add_argument( """--tf_checkpoint_path""", type=str, required=True, help="""Path to the TensorFlow Token Dropping checkpoint path.""" ) parser.add_argument( """--bert_config_file""", type=str, required=True, help="""The config json file corresponding to the BERT model. This specifies the model architecture.""", ) parser.add_argument( """--pytorch_dump_path""", type=str, required=True, help="""Path to the output PyTorch model.""", ) SCREAMING_SNAKE_CASE : Optional[int] = parser.parse_args() convert_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)
24
0
"""simple docstring""" from __future__ import annotations SCREAMING_SNAKE_CASE : Any = list[list[int]] # assigning initial values to the grid SCREAMING_SNAKE_CASE : List[Any] = [ [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 SCREAMING_SNAKE_CASE : Tuple = [ [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 lowercase ( _snake_case : Optional[Any] , _snake_case : Optional[Any] , _snake_case : Tuple , _snake_case : List[Any] ) ->Any: """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 lowercase ( _snake_case : Union[str, Any] ) ->Optional[int]: """simple docstring""" for i in range(9 ): for j in range(9 ): if grid[i][j] == 0: return i, j return None def lowercase ( _snake_case : str ) ->Optional[Any]: """simple docstring""" if location := find_empty_location(SCREAMING_SNAKE_CASE__ ): __snake_case , __snake_case : str = location else: # If the location is ``None``, then the grid is solved. return grid for digit in range(1 , 10 ): if is_safe(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): __snake_case : List[Any] = digit if sudoku(SCREAMING_SNAKE_CASE__ ) is not None: return grid __snake_case : List[Any] = 0 return None def lowercase ( _snake_case : Dict ) ->List[Any]: """simple docstring""" for row in grid: for cell in row: print(SCREAMING_SNAKE_CASE__ , end=''' ''' ) print() if __name__ == "__main__": # make a copy of grid so that you can compare with the unmodified grid for example_grid in (initial_grid, no_solution): print("""\nExample grid:\n""" + """=""" * 20) print_solution(example_grid) print("""\nExample grid solution:""") SCREAMING_SNAKE_CASE : Dict = sudoku(example_grid) if solution is not None: print_solution(solution) else: print("""Cannot find a solution.""")
102
import gc import unittest from parameterized import parameterized from diffusers import FlaxUNetaDConditionModel from diffusers.utils import is_flax_available from diffusers.utils.testing_utils import load_hf_numpy, require_flax, slow if is_flax_available(): import jax import jax.numpy as jnp @slow @require_flax class snake_case_ ( unittest.TestCase ): '''simple docstring''' def snake_case__( self : Any , _UpperCamelCase : Any , _UpperCamelCase : Tuple ) ->List[Any]: return f'''gaussian_noise_s={seed}_shape={'_'.join([str(_UpperCamelCase ) for s in shape] )}.npy''' def snake_case__( self : Any ) ->List[str]: # clean up the VRAM after each test super().tearDown() gc.collect() def snake_case__( self : int , _UpperCamelCase : Union[str, Any]=0 , _UpperCamelCase : int=(4, 4, 6_4, 6_4) , _UpperCamelCase : Optional[int]=False ) ->Tuple: snake_case_ = jnp.bfloataa if fpaa else jnp.floataa snake_case_ = jnp.array(load_hf_numpy(self.get_file_format(_UpperCamelCase , _UpperCamelCase ) ) , dtype=_UpperCamelCase ) return image def snake_case__( self : List[Any] , _UpperCamelCase : Optional[Any]=False , _UpperCamelCase : Optional[int]="CompVis/stable-diffusion-v1-4" ) ->Optional[Any]: snake_case_ = jnp.bfloataa if fpaa else jnp.floataa snake_case_ = '''bf16''' if fpaa else None snake_case_, snake_case_ = FlaxUNetaDConditionModel.from_pretrained( _UpperCamelCase , subfolder='''unet''' , dtype=_UpperCamelCase , revision=_UpperCamelCase ) return model, params def snake_case__( self : Dict , _UpperCamelCase : List[Any]=0 , _UpperCamelCase : Tuple=(4, 7_7, 7_6_8) , _UpperCamelCase : List[Any]=False ) ->int: snake_case_ = jnp.bfloataa if fpaa else jnp.floataa snake_case_ = jnp.array(load_hf_numpy(self.get_file_format(_UpperCamelCase , _UpperCamelCase ) ) , dtype=_UpperCamelCase ) return hidden_states @parameterized.expand( [ # fmt: off [8_3, 4, [-0.2323, -0.1304, 0.0813, -0.3093, -0.0919, -0.1571, -0.1125, -0.5806]], [1_7, 0.55, [-0.0831, -0.2443, 0.0901, -0.0919, 0.3396, 0.0103, -0.3743, 0.0701]], [8, 0.89, [-0.4863, 0.0859, 0.0875, -0.1658, 0.9199, -0.0114, 0.4839, 0.4639]], [3, 1_0_0_0, [-0.5649, 0.2402, -0.5518, 0.1248, 1.1328, -0.2443, -0.0325, -1.0078]], # fmt: on ] ) def snake_case__( self : Optional[Any] , _UpperCamelCase : List[Any] , _UpperCamelCase : List[str] , _UpperCamelCase : Optional[int] ) ->Union[str, Any]: snake_case_, snake_case_ = self.get_unet_model(model_id='''CompVis/stable-diffusion-v1-4''' , fpaa=_UpperCamelCase ) snake_case_ = self.get_latents(_UpperCamelCase , fpaa=_UpperCamelCase ) snake_case_ = self.get_encoder_hidden_states(_UpperCamelCase , fpaa=_UpperCamelCase ) snake_case_ = model.apply( {'''params''': params} , _UpperCamelCase , jnp.array(_UpperCamelCase , dtype=jnp.intaa ) , encoder_hidden_states=_UpperCamelCase , ).sample assert sample.shape == latents.shape snake_case_ = jnp.asarray(jax.device_get((sample[-1, -2:, -2:, :2].flatten()) ) , dtype=jnp.floataa ) snake_case_ = jnp.array(_UpperCamelCase , dtype=jnp.floataa ) # Found torch (float16) and flax (bfloat16) outputs to be within this tolerance, in the same hardware assert jnp.allclose(_UpperCamelCase , _UpperCamelCase , atol=1e-2 ) @parameterized.expand( [ # fmt: off [8_3, 4, [0.1514, 0.0807, 0.1624, 0.1016, -0.1896, 0.0263, 0.0677, 0.2310]], [1_7, 0.55, [0.1164, -0.0216, 0.0170, 0.1589, -0.3120, 0.1005, -0.0581, -0.1458]], [8, 0.89, [-0.1758, -0.0169, 0.1004, -0.1411, 0.1312, 0.1103, -0.1996, 0.2139]], [3, 1_0_0_0, [0.1214, 0.0352, -0.0731, -0.1562, -0.0994, -0.0906, -0.2340, -0.0539]], # fmt: on ] ) def snake_case__( self : Optional[int] , _UpperCamelCase : Optional[Any] , _UpperCamelCase : Union[str, Any] , _UpperCamelCase : str ) ->Dict: snake_case_, snake_case_ = self.get_unet_model(model_id='''stabilityai/stable-diffusion-2''' , fpaa=_UpperCamelCase ) snake_case_ = self.get_latents(_UpperCamelCase , shape=(4, 4, 9_6, 9_6) , fpaa=_UpperCamelCase ) snake_case_ = self.get_encoder_hidden_states(_UpperCamelCase , shape=(4, 7_7, 1_0_2_4) , fpaa=_UpperCamelCase ) snake_case_ = model.apply( {'''params''': params} , _UpperCamelCase , jnp.array(_UpperCamelCase , dtype=jnp.intaa ) , encoder_hidden_states=_UpperCamelCase , ).sample assert sample.shape == latents.shape snake_case_ = jnp.asarray(jax.device_get((sample[-1, -2:, -2:, :2].flatten()) ) , dtype=jnp.floataa ) snake_case_ = jnp.array(_UpperCamelCase , dtype=jnp.floataa ) # Found torch (float16) and flax (bfloat16) outputs to be within this tolerance, on the same hardware assert jnp.allclose(_UpperCamelCase , _UpperCamelCase , atol=1e-2 )
8
0
"""simple docstring""" from typing import Callable, Optional, Union from ...configuration_utils import PretrainedConfig from ...utils import logging lowercase__ = logging.get_logger(__name__) lowercase__ = { """microsoft/xprophetnet-large-wiki100-cased""": ( """https://huggingface.co/microsoft/xprophetnet-large-wiki100-cased/resolve/main/config.json""" ), } class lowerCAmelCase__ ( lowercase ): '''simple docstring''' lowerCamelCase__ = """xlm-prophetnet""" lowerCamelCase__ = ["""past_key_values"""] lowerCamelCase__ = { """num_attention_heads""": """num_encoder_attention_heads""", } def __init__( self , lowercase = 0.1 , lowercase = "gelu" , lowercase = 30522 , lowercase = 1024 , lowercase = 4096 , lowercase = 12 , lowercase = 16 , lowercase = 4096 , lowercase = 12 , lowercase = 16 , lowercase = 0.1 , lowercase = 0.1 , lowercase = 512 , lowercase = 0.02 , lowercase = True , lowercase = True , lowercase = 0 , lowercase = 2 , lowercase = 32 , lowercase = 128 , lowercase = False , lowercase = 0.0 , lowercase = True , lowercase = 0 , lowercase = 1 , lowercase = 2 , **lowercase , ): _lowerCamelCase : Dict = vocab_size _lowerCamelCase : Dict = hidden_size _lowerCamelCase : Optional[int] = encoder_ffn_dim _lowerCamelCase : Union[str, Any] = num_encoder_layers _lowerCamelCase : Union[str, Any] = num_encoder_attention_heads _lowerCamelCase : Optional[int] = decoder_ffn_dim _lowerCamelCase : int = num_decoder_layers _lowerCamelCase : Optional[Any] = num_decoder_attention_heads _lowerCamelCase : str = max_position_embeddings _lowerCamelCase : Optional[Any] = init_std # Normal(0, this parameter) _lowerCamelCase : int = activation_function # parameters for xlmprophetnet _lowerCamelCase : Tuple = ngram _lowerCamelCase : Optional[Any] = num_buckets _lowerCamelCase : Optional[int] = relative_max_distance _lowerCamelCase : List[str] = disable_ngram_loss _lowerCamelCase : Tuple = eps # 3 Types of Dropout _lowerCamelCase : str = attention_dropout _lowerCamelCase : List[Any] = activation_dropout _lowerCamelCase : Any = dropout _lowerCamelCase : List[str] = use_cache super().__init__( pad_token_id=lowercase , bos_token_id=lowercase , eos_token_id=lowercase , is_encoder_decoder=lowercase , add_cross_attention=lowercase , decoder_start_token_id=lowercase , **lowercase , ) @property def A_ ( self ): return self.num_encoder_layers + self.num_decoder_layers @num_hidden_layers.setter def A_ ( self , lowercase ): raise NotImplementedError( 'This model does not support the setting of `num_hidden_layers`. Please set `num_encoder_layers` and' ' `num_decoder_layers`.' )
351
"""simple docstring""" from typing import Optional, Union import numpy as np from ...image_processing_utils import BaseImageProcessor, BatchFeature from ...image_transforms import get_image_size, pad, rescale, to_channel_dimension_format from ...image_utils import ChannelDimension, ImageInput, make_list_of_images, to_numpy_array, valid_images from ...utils import TensorType, logging lowercase__ = logging.get_logger(__name__) class lowerCAmelCase__ ( lowercase ): '''simple docstring''' lowerCamelCase__ = ["""pixel_values"""] def __init__( self , lowercase = True , lowercase = 1 / 255 , lowercase = True , lowercase = 8 , **lowercase , ): super().__init__(**lowercase ) _lowerCamelCase : Optional[Any] = do_rescale _lowerCamelCase : Union[str, Any] = rescale_factor _lowerCamelCase : Any = do_pad _lowerCamelCase : Optional[int] = pad_size def A_ ( self , lowercase , lowercase , lowercase = None , **lowercase ): return rescale(lowercase , scale=lowercase , data_format=lowercase , **lowercase ) def A_ ( self , lowercase , lowercase , lowercase = None ): _lowerCamelCase, _lowerCamelCase : Tuple = get_image_size(lowercase ) _lowerCamelCase : Union[str, Any] = (old_height // size + 1) * size - old_height _lowerCamelCase : Tuple = (old_width // size + 1) * size - old_width return pad(lowercase , ((0, pad_height), (0, pad_width)) , mode='symmetric' , data_format=lowercase ) def A_ ( self , lowercase , lowercase = None , lowercase = None , lowercase = None , lowercase = None , lowercase = None , lowercase = ChannelDimension.FIRST , **lowercase , ): _lowerCamelCase : List[str] = do_rescale if do_rescale is not None else self.do_rescale _lowerCamelCase : List[str] = rescale_factor if rescale_factor is not None else self.rescale_factor _lowerCamelCase : Any = do_pad if do_pad is not None else self.do_pad _lowerCamelCase : int = pad_size if pad_size is not None else self.pad_size _lowerCamelCase : Dict = make_list_of_images(lowercase ) if not valid_images(lowercase ): raise ValueError( 'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, ' 'torch.Tensor, tf.Tensor or jax.ndarray.' ) if do_rescale and rescale_factor is None: raise ValueError('Rescale factor must be specified if do_rescale is True.' ) # All transformations expect numpy arrays. _lowerCamelCase : Dict = [to_numpy_array(lowercase ) for image in images] if do_rescale: _lowerCamelCase : str = [self.rescale(image=lowercase , scale=lowercase ) for image in images] if do_pad: _lowerCamelCase : str = [self.pad(lowercase , size=lowercase ) for image in images] _lowerCamelCase : Any = [to_channel_dimension_format(lowercase , lowercase ) for image in images] _lowerCamelCase : Union[str, Any] = {'pixel_values': images} return BatchFeature(data=lowercase , tensor_type=lowercase )
12
0
import dataclasses import re import string from typing import Any, Dict, Iterator, List, Mapping, Optional, Sequence, Tuple import numpy as np from . import residue_constants lowerCAmelCase : Any = Mapping[str, np.ndarray] lowerCAmelCase : int = Mapping[str, Any] # Is a nested dict. lowerCAmelCase : Optional[Any] = 0.01 @dataclasses.dataclass(frozen=UpperCAmelCase_ ) class __lowercase : """simple docstring""" _UpperCAmelCase : np.ndarray # [num_res, num_atom_type, 3] # Amino-acid type for each residue represented as an integer between 0 and # 20, where 20 is 'X'. _UpperCAmelCase : np.ndarray # [num_res] # Binary float mask to indicate presence of a particular atom. 1.0 if an atom # is present and 0.0 if not. This should be used for loss masking. _UpperCAmelCase : np.ndarray # [num_res, num_atom_type] # Residue index as used in PDB. It is not necessarily continuous or 0-indexed. _UpperCAmelCase : np.ndarray # [num_res] # B-factors, or temperature factors, of each residue (in sq. angstroms units), # representing the displacement of the residue from its ground truth mean # value. _UpperCAmelCase : np.ndarray # [num_res, num_atom_type] # Chain indices for multi-chain predictions _UpperCAmelCase : Optional[np.ndarray] = None # Optional remark about the protein. Included as a comment in output PDB # files _UpperCAmelCase : Optional[str] = None # Templates used to generate this protein (prediction-only) _UpperCAmelCase : Optional[Sequence[str]] = None # Chain corresponding to each parent _UpperCAmelCase : Optional[Sequence[int]] = None def A_ ( _UpperCAmelCase ): SCREAMING_SNAKE_CASE_: Optional[Any] = R"(\[[A-Z]+\]\n)" SCREAMING_SNAKE_CASE_: List[str] = [tag.strip() for tag in re.split(_UpperCAmelCase , _UpperCAmelCase ) if len(_UpperCAmelCase ) > 0] SCREAMING_SNAKE_CASE_: Iterator[Tuple[str, List[str]]] = zip(tags[0::2] , [l.split("\n" ) for l in tags[1::2]] ) SCREAMING_SNAKE_CASE_: List[str] = ["N", "CA", "C"] SCREAMING_SNAKE_CASE_: Any = None SCREAMING_SNAKE_CASE_: Optional[Any] = None SCREAMING_SNAKE_CASE_: List[str] = None for g in groups: if "[PRIMARY]" == g[0]: SCREAMING_SNAKE_CASE_: Optional[int] = g[1][0].strip() for i in range(len(_UpperCAmelCase ) ): if seq[i] not in residue_constants.restypes: SCREAMING_SNAKE_CASE_: Union[str, Any] = "X" # FIXME: strings are immutable SCREAMING_SNAKE_CASE_: Tuple = np.array( [residue_constants.restype_order.get(_UpperCAmelCase , residue_constants.restype_num ) for res_symbol in seq] ) elif "[TERTIARY]" == g[0]: SCREAMING_SNAKE_CASE_: List[List[float]] = [] for axis in range(3 ): tertiary.append(list(map(_UpperCAmelCase , g[1][axis].split() ) ) ) SCREAMING_SNAKE_CASE_: List[Any] = np.array(_UpperCAmelCase ) SCREAMING_SNAKE_CASE_: int = np.zeros((len(tertiary[0] ) // 3, residue_constants.atom_type_num, 3) ).astype(np.floataa ) for i, atom in enumerate(_UpperCAmelCase ): SCREAMING_SNAKE_CASE_: str = np.transpose(tertiary_np[:, i::3] ) atom_positions *= PICO_TO_ANGSTROM elif "[MASK]" == g[0]: SCREAMING_SNAKE_CASE_: Optional[int] = np.array(list(map({"-": 0, "+": 1}.get , g[1][0].strip() ) ) ) SCREAMING_SNAKE_CASE_: Any = np.zeros( ( len(_UpperCAmelCase ), residue_constants.atom_type_num, ) ).astype(np.floataa ) for i, atom in enumerate(_UpperCAmelCase ): SCREAMING_SNAKE_CASE_: str = 1 atom_mask *= mask[..., None] assert aatype is not None return Protein( atom_positions=_UpperCAmelCase , atom_mask=_UpperCAmelCase , aatype=_UpperCAmelCase , residue_index=np.arange(len(_UpperCAmelCase ) ) , b_factors=_UpperCAmelCase , ) def A_ ( _UpperCAmelCase , _UpperCAmelCase = 0 ): SCREAMING_SNAKE_CASE_: List[str] = [] SCREAMING_SNAKE_CASE_: Any = prot.remark if remark is not None: pdb_headers.append(f"REMARK {remark}" ) SCREAMING_SNAKE_CASE_: Any = prot.parents SCREAMING_SNAKE_CASE_: Dict = prot.parents_chain_index if parents is not None and parents_chain_index is not None: SCREAMING_SNAKE_CASE_: Optional[int] = [p for i, p in zip(_UpperCAmelCase , _UpperCAmelCase ) if i == chain_id] if parents is None or len(_UpperCAmelCase ) == 0: SCREAMING_SNAKE_CASE_: Optional[int] = ["N/A"] pdb_headers.append(f"PARENT {' '.join(_UpperCAmelCase )}" ) return pdb_headers def A_ ( _UpperCAmelCase , _UpperCAmelCase ): SCREAMING_SNAKE_CASE_: List[str] = [] SCREAMING_SNAKE_CASE_: List[str] = pdb_str.split("\n" ) SCREAMING_SNAKE_CASE_: Optional[int] = prot.remark if remark is not None: out_pdb_lines.append(f"REMARK {remark}" ) SCREAMING_SNAKE_CASE_: List[List[str]] if prot.parents is not None and len(prot.parents ) > 0: SCREAMING_SNAKE_CASE_: Optional[int] = [] if prot.parents_chain_index is not None: SCREAMING_SNAKE_CASE_: Dict[str, List[str]] = {} for p, i in zip(prot.parents , prot.parents_chain_index ): parent_dict.setdefault(str(_UpperCAmelCase ) , [] ) parent_dict[str(_UpperCAmelCase )].append(_UpperCAmelCase ) SCREAMING_SNAKE_CASE_: List[str] = max([int(_UpperCAmelCase ) for chain_idx in parent_dict] ) for i in range(max_idx + 1 ): SCREAMING_SNAKE_CASE_: List[str] = parent_dict.get(str(_UpperCAmelCase ) , ["N/A"] ) parents_per_chain.append(_UpperCAmelCase ) else: parents_per_chain.append(list(prot.parents ) ) else: SCREAMING_SNAKE_CASE_: List[Any] = [["N/A"]] def make_parent_line(_UpperCAmelCase ) -> str: return f"PARENT {' '.join(_UpperCAmelCase )}" out_pdb_lines.append(make_parent_line(parents_per_chain[0] ) ) SCREAMING_SNAKE_CASE_: Union[str, Any] = 0 for i, l in enumerate(_UpperCAmelCase ): if "PARENT" not in l and "REMARK" not in l: out_pdb_lines.append(_UpperCAmelCase ) if "TER" in l and "END" not in lines[i + 1]: chain_counter += 1 if not chain_counter >= len(_UpperCAmelCase ): SCREAMING_SNAKE_CASE_: Any = parents_per_chain[chain_counter] else: SCREAMING_SNAKE_CASE_: Union[str, Any] = ["N/A"] out_pdb_lines.append(make_parent_line(_UpperCAmelCase ) ) return "\n".join(_UpperCAmelCase ) def A_ ( _UpperCAmelCase ): SCREAMING_SNAKE_CASE_: int = residue_constants.restypes + ["X"] def res_atoa(_UpperCAmelCase ) -> str: return residue_constants.restype_atoa.get(restypes[r] , "UNK" ) SCREAMING_SNAKE_CASE_: int = residue_constants.atom_types SCREAMING_SNAKE_CASE_: List[str] = [] SCREAMING_SNAKE_CASE_: Optional[int] = prot.atom_mask SCREAMING_SNAKE_CASE_: Optional[Any] = prot.aatype SCREAMING_SNAKE_CASE_: Optional[Any] = prot.atom_positions SCREAMING_SNAKE_CASE_: int = prot.residue_index.astype(np.intaa ) SCREAMING_SNAKE_CASE_: Dict = prot.b_factors SCREAMING_SNAKE_CASE_: str = prot.chain_index if np.any(aatype > residue_constants.restype_num ): raise ValueError("Invalid aatypes." ) SCREAMING_SNAKE_CASE_: Optional[int] = get_pdb_headers(_UpperCAmelCase ) if len(_UpperCAmelCase ) > 0: pdb_lines.extend(_UpperCAmelCase ) SCREAMING_SNAKE_CASE_: List[Any] = aatype.shape[0] SCREAMING_SNAKE_CASE_: str = 1 SCREAMING_SNAKE_CASE_: List[Any] = 0 SCREAMING_SNAKE_CASE_: List[Any] = string.ascii_uppercase SCREAMING_SNAKE_CASE_: int = None # Add all atom sites. for i in range(_UpperCAmelCase ): SCREAMING_SNAKE_CASE_: List[str] = res_atoa(aatype[i] ) for atom_name, pos, mask, b_factor in zip(_UpperCAmelCase , atom_positions[i] , atom_mask[i] , b_factors[i] ): if mask < 0.5: continue SCREAMING_SNAKE_CASE_: List[Any] = "ATOM" SCREAMING_SNAKE_CASE_: Optional[Any] = atom_name if len(_UpperCAmelCase ) == 4 else f" {atom_name}" SCREAMING_SNAKE_CASE_: List[str] = "" SCREAMING_SNAKE_CASE_: Optional[int] = "" SCREAMING_SNAKE_CASE_: List[str] = 1.0_0 SCREAMING_SNAKE_CASE_: int = atom_name[0] # Protein supports only C, N, O, S, this works. SCREAMING_SNAKE_CASE_: Optional[Any] = "" SCREAMING_SNAKE_CASE_: Dict = "A" if chain_index is not None: SCREAMING_SNAKE_CASE_: int = chain_tags[chain_index[i]] # PDB is a columnar format, every space matters here! SCREAMING_SNAKE_CASE_: Tuple = ( f"{record_type:<6}{atom_index:>5} {name:<4}{alt_loc:>1}" f"{res_name_a:>3} {chain_tag:>1}" f"{residue_index[i]:>4}{insertion_code:>1} " f"{pos[0]:>8.3f}{pos[1]:>8.3f}{pos[2]:>8.3f}" f"{occupancy:>6.2f}{b_factor:>6.2f} " f"{element:>2}{charge:>2}" ) pdb_lines.append(_UpperCAmelCase ) atom_index += 1 SCREAMING_SNAKE_CASE_: Optional[Any] = i == n - 1 if chain_index is not None: if i != n - 1 and chain_index[i + 1] != prev_chain_index: SCREAMING_SNAKE_CASE_: Dict = True SCREAMING_SNAKE_CASE_: List[str] = chain_index[i + 1] if should_terminate: # Close the chain. SCREAMING_SNAKE_CASE_: int = "TER" SCREAMING_SNAKE_CASE_: int = ( f"{chain_end:<6}{atom_index:>5} {res_atoa(aatype[i] ):>3} {chain_tag:>1}{residue_index[i]:>4}" ) pdb_lines.append(_UpperCAmelCase ) atom_index += 1 if i != n - 1: # "prev" is a misnomer here. This happens at the beginning of # each new chain. pdb_lines.extend(get_pdb_headers(_UpperCAmelCase , _UpperCAmelCase ) ) pdb_lines.append("END" ) pdb_lines.append("" ) return "\n".join(_UpperCAmelCase ) def A_ ( _UpperCAmelCase ): return residue_constants.STANDARD_ATOM_MASK[prot.aatype] def A_ ( _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , ): return Protein( aatype=features["aatype"] , atom_positions=result["final_atom_positions"] , atom_mask=result["final_atom_mask"] , residue_index=features["residue_index"] + 1 , b_factors=b_factors if b_factors is not None else np.zeros_like(result["final_atom_mask"] ) , chain_index=_UpperCAmelCase , remark=_UpperCAmelCase , parents=_UpperCAmelCase , parents_chain_index=_UpperCAmelCase , )
13
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 lowerCAmelCase_ ( __A, __A ) -> int: '''simple docstring''' UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights["token_embedder"]["embedding"] ) ) UpperCAmelCase__ = nn.Parameter( torch.FloatTensor(weights["Embed_0"]["embedding"] ), requires_grad=__A ) 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 lowerCAmelCase_ ( __A, __A ) -> Tuple: '''simple docstring''' UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights["input_proj"]["kernel"].T ) ) UpperCAmelCase__ = nn.Parameter( torch.FloatTensor(weights["Embed_0"]["embedding"] ), requires_grad=__A ) 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 lowerCAmelCase_ ( __A, __A ) -> 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=__A ) 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 lowerCAmelCase_ ( __A ) -> int: '''simple docstring''' UpperCAmelCase__ = checkpoints.load_tax_checkpoint(args.checkpoint_path ) UpperCAmelCase__ = jnp.tree_util.tree_map(onp.array, __A ) 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(__A, __A ) UpperCAmelCase__ = inference.InferenceModel(args.checkpoint_path, __A ) 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"], __A ) UpperCAmelCase__ = load_continuous_encoder(ta_checkpoint["target"]["continuous_encoder"], __A ) UpperCAmelCase__ = load_decoder(ta_checkpoint["target"]["decoder"], __A ) UpperCAmelCase__ = OnnxRuntimeModel.from_pretrained("kashif/soundstream_mel_decoder" ) UpperCAmelCase__ = SpectrogramDiffusionPipeline( notes_encoder=__A, continuous_encoder=__A, decoder=__A, scheduler=__A, melgan=__A, ) 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)
65
0
import unittest import numpy as np from transformers import BertConfig, is_flax_available from transformers.testing_utils import require_flax, slow from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask if is_flax_available(): from transformers.models.bert.modeling_flax_bert import ( FlaxBertForMaskedLM, FlaxBertForMultipleChoice, FlaxBertForNextSentencePrediction, FlaxBertForPreTraining, FlaxBertForQuestionAnswering, FlaxBertForSequenceClassification, FlaxBertForTokenClassification, FlaxBertModel, ) class __lowerCAmelCase ( unittest.TestCase ): def __init__( self : Tuple , A : Union[str, Any] , A : Union[str, Any]=13 , A : List[Any]=7 , A : int=True , A : List[str]=True , A : Dict=True , A : Union[str, Any]=True , A : Tuple=99 , A : Tuple=32 , A : Tuple=5 , A : int=4 , A : List[str]=37 , A : Tuple="gelu" , A : int=0.1 , A : Tuple=0.1 , A : Any=5_12 , A : int=16 , A : Dict=2 , A : Tuple=0.0_2 , A : Dict=4 , ) -> Any: """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 : List[Any]) -> Optional[int]: """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 = BertConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , is_decoder=A , initializer_range=self.initializer_range , ) return config, input_ids, token_type_ids, attention_mask def _lowerCamelCase ( self : int) -> 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 def _lowerCamelCase ( self : Tuple) -> List[str]: """simple docstring""" _UpperCAmelCase = self.prepare_config_and_inputs() _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = config_and_inputs _UpperCAmelCase = True _UpperCAmelCase = floats_tensor([self.batch_size, self.seq_length, self.hidden_size]) _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , vocab_size=2) return ( config, input_ids, attention_mask, encoder_hidden_states, encoder_attention_mask, ) @require_flax class __lowerCAmelCase ( A , unittest.TestCase ): UpperCamelCase = True UpperCamelCase = ( ( FlaxBertModel, FlaxBertForPreTraining, FlaxBertForMaskedLM, FlaxBertForMultipleChoice, FlaxBertForQuestionAnswering, FlaxBertForNextSentencePrediction, FlaxBertForSequenceClassification, FlaxBertForTokenClassification, FlaxBertForQuestionAnswering, ) if is_flax_available() else () ) def _lowerCamelCase ( self : str) -> Dict: """simple docstring""" _UpperCAmelCase = FlaxBertModelTester(self) @slow def _lowerCamelCase ( self : Optional[Any]) -> Optional[int]: """simple docstring""" _UpperCAmelCase = FlaxBertModel.from_pretrained('bert-base-cased') _UpperCAmelCase = model(np.ones((1, 1))) self.assertIsNotNone(A)
359
import string import numpy def A ( _UpperCAmelCase : int , _UpperCAmelCase : int ) -> int: '''simple docstring''' return b if a == 0 else greatest_common_divisor(b % a , _UpperCAmelCase ) class __lowerCAmelCase : UpperCamelCase = string.ascii_uppercase + string.digits # This cipher takes alphanumerics into account # i.e. a total of 36 characters # take x and return x % len(key_string) UpperCamelCase = numpy.vectorize(lambda A : x % 3_6 ) UpperCamelCase = numpy.vectorize(A ) def __init__( self : Tuple , A : numpy.ndarray) -> None: """simple docstring""" _UpperCAmelCase = self.modulus(A) # mod36 calc's on the encrypt key self.check_determinant() # validate the determinant of the encryption key _UpperCAmelCase = encrypt_key.shape[0] def _lowerCamelCase ( self : str , A : str) -> int: """simple docstring""" return self.key_string.index(A) def _lowerCamelCase ( self : Any , A : int) -> str: """simple docstring""" return self.key_string[round(A)] def _lowerCamelCase ( self : Union[str, Any]) -> None: """simple docstring""" _UpperCAmelCase = round(numpy.linalg.det(self.encrypt_key)) if det < 0: _UpperCAmelCase = det % len(self.key_string) _UpperCAmelCase = len(self.key_string) if greatest_common_divisor(A , len(self.key_string)) != 1: _UpperCAmelCase = ( F"determinant modular {req_l} of encryption key({det}) " F"is not co prime w.r.t {req_l}.\nTry another key." ) raise ValueError(A) def _lowerCamelCase ( self : Union[str, Any] , A : str) -> str: """simple docstring""" _UpperCAmelCase = [char for char in text.upper() if char in self.key_string] _UpperCAmelCase = chars[-1] while len(A) % self.break_key != 0: chars.append(A) return "".join(A) def _lowerCamelCase ( self : Union[str, Any] , A : str) -> str: """simple docstring""" _UpperCAmelCase = self.process_text(text.upper()) _UpperCAmelCase = '' for i in range(0 , len(A) - self.break_key + 1 , self.break_key): _UpperCAmelCase = text[i : i + self.break_key] _UpperCAmelCase = [self.replace_letters(A) for char in batch] _UpperCAmelCase = numpy.array([vec]).T _UpperCAmelCase = self.modulus(self.encrypt_key.dot(A)).T.tolist()[ 0 ] _UpperCAmelCase = ''.join( self.replace_digits(A) for num in batch_encrypted) encrypted += encrypted_batch return encrypted def _lowerCamelCase ( self : Optional[Any]) -> numpy.ndarray: """simple docstring""" _UpperCAmelCase = round(numpy.linalg.det(self.encrypt_key)) if det < 0: _UpperCAmelCase = det % len(self.key_string) _UpperCAmelCase = None for i in range(len(self.key_string)): if (det * i) % len(self.key_string) == 1: _UpperCAmelCase = i break _UpperCAmelCase = ( det_inv * numpy.linalg.det(self.encrypt_key) * numpy.linalg.inv(self.encrypt_key) ) return self.to_int(self.modulus(A)) def _lowerCamelCase ( self : Tuple , A : str) -> str: """simple docstring""" _UpperCAmelCase = self.make_decrypt_key() _UpperCAmelCase = self.process_text(text.upper()) _UpperCAmelCase = '' for i in range(0 , len(A) - self.break_key + 1 , self.break_key): _UpperCAmelCase = text[i : i + self.break_key] _UpperCAmelCase = [self.replace_letters(A) for char in batch] _UpperCAmelCase = numpy.array([vec]).T _UpperCAmelCase = self.modulus(decrypt_key.dot(A)).T.tolist()[0] _UpperCAmelCase = ''.join( self.replace_digits(A) for num in batch_decrypted) decrypted += decrypted_batch return decrypted def A ( ) -> None: '''simple docstring''' _UpperCAmelCase = int(input('Enter the order of the encryption key: ' ) ) _UpperCAmelCase = [] print('Enter each row of the encryption key with space separated integers' ) for _ in range(_UpperCAmelCase ): _UpperCAmelCase = [int(_UpperCAmelCase ) for x in input().split()] hill_matrix.append(_UpperCAmelCase ) _UpperCAmelCase = HillCipher(numpy.array(_UpperCAmelCase ) ) print('Would you like to encrypt or decrypt some text? (1 or 2)' ) _UpperCAmelCase = input('\n1. Encrypt\n2. Decrypt\n' ) if option == "1": _UpperCAmelCase = input('What text would you like to encrypt?: ' ) print('Your encrypted text is:' ) print(hc.encrypt(_UpperCAmelCase ) ) elif option == "2": _UpperCAmelCase = input('What text would you like to decrypt?: ' ) print('Your decrypted text is:' ) print(hc.decrypt(_UpperCAmelCase ) ) if __name__ == "__main__": import doctest doctest.testmod() main()
290
0
def __magic_name__ ( A : int ): '''simple docstring''' if bit_count < 0: raise ValueError("The given input must be positive" ) # get the generated string sequence a = gray_code_sequence_string(A ) # # convert them to integers for i in range(len(A ) ): a = int(sequence[i], 2 ) return sequence def __magic_name__ ( A : int ): '''simple docstring''' if bit_count == 0: return ["0"] if bit_count == 1: return ["0", "1"] a = 1 << bit_count # defines the length of the sequence # 1<< n is equivalent to 2^n # recursive answer will generate answer for n-1 bits a = gray_code_sequence_string(bit_count - 1 ) a = [] # append 0 to first half of the smaller sequence generated for i in range(seq_len // 2 ): a = "0" + smaller_sequence[i] sequence.append(A ) # append 1 to second half ... start from the end of the list for i in reversed(range(seq_len // 2 ) ): a = "1" + smaller_sequence[i] sequence.append(A ) return sequence if __name__ == "__main__": import doctest doctest.testmod()
107
"""simple docstring""" import os def lowerCamelCase__ ( ) -> List[Any]: with open(os.path.dirname(_lowerCamelCase ) + '/grid.txt' ) as f: lowerCamelCase_ = [] # noqa: E741 for _ in range(20 ): l.append([int(_lowerCamelCase ) for x in f.readline().split()] ) lowerCamelCase_ = 0 # right for i in range(20 ): for j in range(17 ): lowerCamelCase_ = l[i][j] * l[i][j + 1] * l[i][j + 2] * l[i][j + 3] if temp > maximum: lowerCamelCase_ = temp # down for i in range(17 ): for j in range(20 ): lowerCamelCase_ = l[i][j] * l[i + 1][j] * l[i + 2][j] * l[i + 3][j] if temp > maximum: lowerCamelCase_ = temp # diagonal 1 for i in range(17 ): for j in range(17 ): lowerCamelCase_ = l[i][j] * l[i + 1][j + 1] * l[i + 2][j + 2] * l[i + 3][j + 3] if temp > maximum: lowerCamelCase_ = temp # diagonal 2 for i in range(17 ): for j in range(3 , 20 ): lowerCamelCase_ = l[i][j] * l[i + 1][j - 1] * l[i + 2][j - 2] * l[i + 3][j - 3] if temp > maximum: lowerCamelCase_ = temp return maximum if __name__ == "__main__": print(solution())
183
0
from numpy import exp, pi, sqrt def A(__a: Tuple , __a: List[str] = 0.0 , __a: Any = 1.0 ): return 1 / sqrt(2 * pi * sigma**2 ) * exp(-((x - mu) ** 2) / (2 * sigma**2) ) if __name__ == "__main__": import doctest doctest.testmod()
361
import argparse import io import requests import torch from omegaconf import OmegaConf from diffusers import AutoencoderKL from diffusers.pipelines.stable_diffusion.convert_from_ckpt import ( assign_to_checkpoint, conv_attn_to_linear, create_vae_diffusers_config, renew_vae_attention_paths, renew_vae_resnet_paths, ) def A(__a: Tuple , __a: Union[str, Any] ): lowerCAmelCase_ = checkpoint lowerCAmelCase_ = {} lowerCAmelCase_ = vae_state_dict["encoder.conv_in.weight"] lowerCAmelCase_ = vae_state_dict["encoder.conv_in.bias"] lowerCAmelCase_ = vae_state_dict["encoder.conv_out.weight"] lowerCAmelCase_ = vae_state_dict["encoder.conv_out.bias"] lowerCAmelCase_ = vae_state_dict["encoder.norm_out.weight"] lowerCAmelCase_ = vae_state_dict["encoder.norm_out.bias"] lowerCAmelCase_ = vae_state_dict["decoder.conv_in.weight"] lowerCAmelCase_ = vae_state_dict["decoder.conv_in.bias"] lowerCAmelCase_ = vae_state_dict["decoder.conv_out.weight"] lowerCAmelCase_ = vae_state_dict["decoder.conv_out.bias"] lowerCAmelCase_ = vae_state_dict["decoder.norm_out.weight"] lowerCAmelCase_ = vae_state_dict["decoder.norm_out.bias"] lowerCAmelCase_ = vae_state_dict["quant_conv.weight"] lowerCAmelCase_ = vae_state_dict["quant_conv.bias"] lowerCAmelCase_ = vae_state_dict["post_quant_conv.weight"] lowerCAmelCase_ = vae_state_dict["post_quant_conv.bias"] # Retrieves the keys for the encoder down blocks only lowerCAmelCase_ = len({".".join(layer.split("." )[:3] ) for layer in vae_state_dict if "encoder.down" in layer} ) lowerCAmelCase_ = { layer_id: [key for key in vae_state_dict if F"down.{layer_id}" in key] for layer_id in range(__a ) } # Retrieves the keys for the decoder up blocks only lowerCAmelCase_ = len({".".join(layer.split("." )[:3] ) for layer in vae_state_dict if "decoder.up" in layer} ) lowerCAmelCase_ = { layer_id: [key for key in vae_state_dict if F"up.{layer_id}" in key] for layer_id in range(__a ) } for i in range(__a ): lowerCAmelCase_ = [key for key in down_blocks[i] if F"down.{i}" in key and F"down.{i}.downsample" not in key] if F"encoder.down.{i}.downsample.conv.weight" in vae_state_dict: lowerCAmelCase_ = vae_state_dict.pop( F"encoder.down.{i}.downsample.conv.weight" ) lowerCAmelCase_ = vae_state_dict.pop( F"encoder.down.{i}.downsample.conv.bias" ) lowerCAmelCase_ = renew_vae_resnet_paths(__a ) lowerCAmelCase_ = {"old": F"down.{i}.block", "new": F"down_blocks.{i}.resnets"} assign_to_checkpoint(__a , __a , __a , additional_replacements=[meta_path] , config=__a ) lowerCAmelCase_ = [key for key in vae_state_dict if "encoder.mid.block" in key] lowerCAmelCase_ = 2 for i in range(1 , num_mid_res_blocks + 1 ): lowerCAmelCase_ = [key for key in mid_resnets if F"encoder.mid.block_{i}" in key] lowerCAmelCase_ = renew_vae_resnet_paths(__a ) lowerCAmelCase_ = {"old": F"mid.block_{i}", "new": F"mid_block.resnets.{i - 1}"} assign_to_checkpoint(__a , __a , __a , additional_replacements=[meta_path] , config=__a ) lowerCAmelCase_ = [key for key in vae_state_dict if "encoder.mid.attn" in key] lowerCAmelCase_ = renew_vae_attention_paths(__a ) lowerCAmelCase_ = {"old": "mid.attn_1", "new": "mid_block.attentions.0"} assign_to_checkpoint(__a , __a , __a , additional_replacements=[meta_path] , config=__a ) conv_attn_to_linear(__a ) for i in range(__a ): lowerCAmelCase_ = num_up_blocks - 1 - i lowerCAmelCase_ = [ key for key in up_blocks[block_id] if F"up.{block_id}" in key and F"up.{block_id}.upsample" not in key ] if F"decoder.up.{block_id}.upsample.conv.weight" in vae_state_dict: lowerCAmelCase_ = vae_state_dict[ F"decoder.up.{block_id}.upsample.conv.weight" ] lowerCAmelCase_ = vae_state_dict[ F"decoder.up.{block_id}.upsample.conv.bias" ] lowerCAmelCase_ = renew_vae_resnet_paths(__a ) lowerCAmelCase_ = {"old": F"up.{block_id}.block", "new": F"up_blocks.{i}.resnets"} assign_to_checkpoint(__a , __a , __a , additional_replacements=[meta_path] , config=__a ) lowerCAmelCase_ = [key for key in vae_state_dict if "decoder.mid.block" in key] lowerCAmelCase_ = 2 for i in range(1 , num_mid_res_blocks + 1 ): lowerCAmelCase_ = [key for key in mid_resnets if F"decoder.mid.block_{i}" in key] lowerCAmelCase_ = renew_vae_resnet_paths(__a ) lowerCAmelCase_ = {"old": F"mid.block_{i}", "new": F"mid_block.resnets.{i - 1}"} assign_to_checkpoint(__a , __a , __a , additional_replacements=[meta_path] , config=__a ) lowerCAmelCase_ = [key for key in vae_state_dict if "decoder.mid.attn" in key] lowerCAmelCase_ = renew_vae_attention_paths(__a ) lowerCAmelCase_ = {"old": "mid.attn_1", "new": "mid_block.attentions.0"} assign_to_checkpoint(__a , __a , __a , additional_replacements=[meta_path] , config=__a ) conv_attn_to_linear(__a ) return new_checkpoint def A(__a: str , __a: str , ): # Only support V1 lowerCAmelCase_ = requests.get( " https://raw.githubusercontent.com/CompVis/stable-diffusion/main/configs/stable-diffusion/v1-inference.yaml" ) lowerCAmelCase_ = io.BytesIO(r.content ) lowerCAmelCase_ = OmegaConf.load(__a ) lowerCAmelCase_ = 512 lowerCAmelCase_ = "cuda" if torch.cuda.is_available() else "cpu" if checkpoint_path.endswith("safetensors" ): from safetensors import safe_open lowerCAmelCase_ = {} with safe_open(__a , framework="pt" , device="cpu" ) as f: for key in f.keys(): lowerCAmelCase_ = f.get_tensor(__a ) else: lowerCAmelCase_ = torch.load(__a , map_location=__a )["state_dict"] # Convert the VAE model. lowerCAmelCase_ = create_vae_diffusers_config(__a , image_size=__a ) lowerCAmelCase_ = custom_convert_ldm_vae_checkpoint(__a , __a ) lowerCAmelCase_ = AutoencoderKL(**__a ) vae.load_state_dict(__a ) vae.save_pretrained(__a ) if __name__ == "__main__": lowerCamelCase__ = argparse.ArgumentParser() parser.add_argument('''--vae_pt_path''', default=None, type=str, required=True, help='''Path to the VAE.pt to convert.''') parser.add_argument('''--dump_path''', default=None, type=str, required=True, help='''Path to the VAE.pt to convert.''') lowerCamelCase__ = parser.parse_args() vae_pt_to_vae_diffuser(args.vae_pt_path, args.dump_path)
22
0
'''simple docstring''' from urllib.parse import quote import pytest from datasets.utils.hub import hf_hub_url @pytest.mark.parametrize('repo_id' , ['canonical_dataset_name', 'org-name/dataset-name'] ) @pytest.mark.parametrize('path' , ['filename.csv', 'filename with blanks.csv'] ) @pytest.mark.parametrize('revision' , [None, 'v2'] ) def SCREAMING_SNAKE_CASE__ ( __A , __A , __A ) -> List[Any]: _snake_case = hf_hub_url(repo_id=__A , path=__A , revision=__A ) assert url == F'https://huggingface.co/datasets/{repo_id}/resolve/{revision or "main"}/{quote(__A )}'
42
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available _lowercase: Union[str, Any] = { "configuration_bridgetower": [ "BRIDGETOWER_PRETRAINED_CONFIG_ARCHIVE_MAP", "BridgeTowerConfig", "BridgeTowerTextConfig", "BridgeTowerVisionConfig", ], "processing_bridgetower": ["BridgeTowerProcessor"], } try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase: Dict = ["BridgeTowerImageProcessor"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase: int = [ "BRIDGETOWER_PRETRAINED_MODEL_ARCHIVE_LIST", "BridgeTowerForContrastiveLearning", "BridgeTowerForImageAndTextRetrieval", "BridgeTowerForMaskedLM", "BridgeTowerModel", "BridgeTowerPreTrainedModel", ] if TYPE_CHECKING: from .configuration_bridgetower import ( BRIDGETOWER_PRETRAINED_CONFIG_ARCHIVE_MAP, BridgeTowerConfig, BridgeTowerTextConfig, BridgeTowerVisionConfig, ) from .processing_bridgetower import BridgeTowerProcessor try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .image_processing_bridgetower import BridgeTowerImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_bridgetower import ( BRIDGETOWER_PRETRAINED_MODEL_ARCHIVE_LIST, BridgeTowerForContrastiveLearning, BridgeTowerForImageAndTextRetrieval, BridgeTowerForMaskedLM, BridgeTowerModel, BridgeTowerPreTrainedModel, ) else: import sys _lowercase: Optional[Any] = _LazyModule(__name__, globals()["__file__"], _import_structure)
227
0
from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging __UpperCAmelCase : List[str] = logging.get_logger(__name__) __UpperCAmelCase : str = { "camembert-base": "https://huggingface.co/camembert-base/resolve/main/config.json", "umberto-commoncrawl-cased-v1": ( "https://huggingface.co/Musixmatch/umberto-commoncrawl-cased-v1/resolve/main/config.json" ), "umberto-wikipedia-uncased-v1": ( "https://huggingface.co/Musixmatch/umberto-wikipedia-uncased-v1/resolve/main/config.json" ), } class __snake_case ( __lowerCamelCase ): '''simple docstring''' lowerCAmelCase__ = """camembert""" def __init__( self : Optional[Any] , A : Optional[int]=30_522 , A : str=768 , A : str=12 , A : Dict=12 , A : Optional[int]=3_072 , A : Tuple="gelu" , A : Any=0.1 , A : int=0.1 , A : Optional[int]=512 , A : Optional[int]=2 , A : Optional[Any]=0.02 , A : Optional[Any]=1E-12 , A : List[Any]=1 , A : Optional[Any]=0 , A : int=2 , A : List[str]="absolute" , A : Any=True , A : Optional[Any]=None , **A : Optional[int] , ): super().__init__(pad_token_id=A , bos_token_id=A , eos_token_id=A , **A ) __snake_case: Tuple = vocab_size __snake_case: List[Any] = hidden_size __snake_case: Tuple = num_hidden_layers __snake_case: List[str] = num_attention_heads __snake_case: Tuple = hidden_act __snake_case: Optional[Any] = intermediate_size __snake_case: str = hidden_dropout_prob __snake_case: str = attention_probs_dropout_prob __snake_case: Dict = max_position_embeddings __snake_case: int = type_vocab_size __snake_case: List[str] = initializer_range __snake_case: List[str] = layer_norm_eps __snake_case: Union[str, Any] = position_embedding_type __snake_case: List[str] = use_cache __snake_case: Optional[Any] = classifier_dropout class __snake_case ( __lowerCamelCase ): '''simple docstring''' @property def UpperCAmelCase__ ( self : Dict ): if self.task == "multiple-choice": __snake_case: Any = {0: """batch""", 1: """choice""", 2: """sequence"""} else: __snake_case: int = {0: """batch""", 1: """sequence"""} return OrderedDict( [ ("""input_ids""", dynamic_axis), ("""attention_mask""", dynamic_axis), ] )
293
from typing import Dict, List, Optional, Union import numpy as np from .feature_extraction_utils import BatchFeature, FeatureExtractionMixin from .utils import PaddingStrategy, TensorType, is_tf_tensor, is_torch_tensor, logging, to_numpy __UpperCAmelCase : str = logging.get_logger(__name__) class __snake_case ( __lowerCamelCase ): '''simple docstring''' def __init__( self : Any , A : int , A : int , A : float , **A : Optional[int] ): __snake_case: List[str] = feature_size __snake_case: Optional[int] = sampling_rate __snake_case: Any = padding_value __snake_case: Dict = kwargs.pop("""padding_side""" , """right""" ) __snake_case: Union[str, Any] = kwargs.pop("""return_attention_mask""" , A ) super().__init__(**A ) def UpperCAmelCase__ ( self : Optional[Any] , A : Union[ BatchFeature, List[BatchFeature], Dict[str, BatchFeature], Dict[str, List[BatchFeature]], List[Dict[str, BatchFeature]], ] , A : Union[bool, str, PaddingStrategy] = True , A : Optional[int] = None , A : bool = False , A : Optional[int] = None , A : Optional[bool] = None , A : Optional[Union[str, TensorType]] = None , ): # If we have a list of dicts, let's convert it in a dict of lists # We do this to allow using this method as a collate_fn function in PyTorch Dataloader if isinstance(A , (list, tuple) ) and isinstance(processed_features[0] , (dict, BatchFeature) ): __snake_case: Optional[int] = { key: [example[key] for example in processed_features] for key in processed_features[0].keys() } # The model's main input name, usually `input_values`, has be passed for padding if self.model_input_names[0] not in processed_features: raise ValueError( """You should supply an instance of `transformers.BatchFeature` or list of `transformers.BatchFeature`""" f''' to this method that includes {self.model_input_names[0]}, but you provided''' f''' {list(processed_features.keys() )}''' ) __snake_case: List[str] = processed_features[self.model_input_names[0]] __snake_case: Any = ( return_attention_mask if return_attention_mask is not None else self.return_attention_mask ) if len(A ) == 0: if return_attention_mask: __snake_case: Union[str, Any] = [] return processed_features # If we have PyTorch/TF tensors or lists as inputs, we cast them as Numpy arrays # and rebuild them afterwards if no return_tensors is specified # Note that we lose the specific device the tensor may be on for PyTorch __snake_case: int = required_input[0] if isinstance(A , (list, tuple) ): # first_element might be an empty list/tuple in some edge cases so we grab the first non empty element. __snake_case: Optional[int] = 0 while len(required_input[index] ) == 0: index += 1 if index < len(A ): __snake_case: Optional[int] = required_input[index][0] if return_tensors is None: if is_tf_tensor(A ): __snake_case: str = """tf""" elif is_torch_tensor(A ): __snake_case: str = """pt""" elif isinstance(A , (int, float, list, tuple, np.ndarray) ): __snake_case: List[str] = """np""" else: raise ValueError( f'''type of {first_element} unknown: {type(A )}. ''' """Should be one of a python, numpy, pytorch or tensorflow object.""" ) for key, value in processed_features.items(): if isinstance(value[0] , (int, float) ): __snake_case: List[Any] = to_numpy(A ) else: __snake_case: Union[str, Any] = [to_numpy(A ) for v in value] # Convert padding_strategy in PaddingStrategy __snake_case: Union[str, Any] = self._get_padding_strategies(padding=A , max_length=A ) __snake_case: Any = processed_features[self.model_input_names[0]] __snake_case: int = len(A ) if not all(len(A ) == batch_size for v in processed_features.values() ): raise ValueError("""Some items in the output dictionary have a different batch size than others.""" ) __snake_case: Union[str, Any] = [] for i in range(A ): __snake_case: List[Any] = {k: v[i] for k, v in processed_features.items()} # truncation __snake_case: Tuple = self._truncate( A , max_length=A , pad_to_multiple_of=A , truncation=A , ) truncated_inputs.append(A ) if padding_strategy == PaddingStrategy.LONGEST: # make sure that `max_length` cannot be longer than the longest truncated length __snake_case: Optional[Any] = max(len(input_slice[self.model_input_names[0]] ) for input_slice in truncated_inputs ) __snake_case: List[str] = PaddingStrategy.MAX_LENGTH __snake_case: List[Any] = {} for i in range(A ): # padding __snake_case: Any = self._pad( truncated_inputs[i] , max_length=A , padding_strategy=A , pad_to_multiple_of=A , return_attention_mask=A , ) for key, value in outputs.items(): if key not in batch_outputs: __snake_case: Optional[Any] = [] if value.dtype is np.dtype(np.floataa ): __snake_case: str = value.astype(np.floataa ) batch_outputs[key].append(A ) return BatchFeature(A , tensor_type=A ) def UpperCAmelCase__ ( self : int , A : Union[Dict[str, np.ndarray], BatchFeature] , A : Optional[int] = None , A : PaddingStrategy = PaddingStrategy.DO_NOT_PAD , A : Optional[int] = None , A : Optional[bool] = None , ): __snake_case: List[Any] = processed_features[self.model_input_names[0]] if padding_strategy == PaddingStrategy.LONGEST: __snake_case: List[str] = len(A ) if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0): __snake_case: List[Any] = ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of __snake_case: Dict = padding_strategy != PaddingStrategy.DO_NOT_PAD and len(A ) < max_length if return_attention_mask and "attention_mask" not in processed_features: __snake_case: List[str] = np.ones(len(A ) , dtype=np.intaa ) if needs_to_be_padded: __snake_case: Any = max_length - len(A ) if self.padding_side == "right": if return_attention_mask: __snake_case: Optional[int] = np.pad( processed_features["""attention_mask"""] , (0, difference) ) __snake_case: Any = ((0, difference), (0, 0)) if self.feature_size > 1 else (0, difference) __snake_case: Union[str, Any] = np.pad( A , A , """constant""" , constant_values=self.padding_value ) elif self.padding_side == "left": if return_attention_mask: __snake_case: Dict = np.pad( processed_features["""attention_mask"""] , (difference, 0) ) __snake_case: Union[str, Any] = ((difference, 0), (0, 0)) if self.feature_size > 1 else (difference, 0) __snake_case: str = np.pad( A , A , """constant""" , constant_values=self.padding_value ) else: raise ValueError("""Invalid padding strategy:""" + str(self.padding_side ) ) return processed_features def UpperCAmelCase__ ( self : Optional[Any] , A : Union[Dict[str, np.ndarray], BatchFeature] , A : Optional[int] = None , A : Optional[int] = None , A : Optional[bool] = None , ): if not truncation: return processed_features elif truncation and max_length is None: raise ValueError("""When setting ``truncation=True``, make sure that ``max_length`` is defined.""" ) __snake_case: List[str] = processed_features[self.model_input_names[0]] # find `max_length` that fits `pad_to_multiple_of` if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0): __snake_case: List[Any] = ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of __snake_case: Tuple = len(A ) > max_length if needs_to_be_truncated: __snake_case: List[Any] = processed_features[self.model_input_names[0]][:max_length] if "attention_mask" in processed_features: __snake_case: int = processed_features["""attention_mask"""][:max_length] return processed_features def UpperCAmelCase__ ( self : int , A : int=False , A : int=None ): # Get padding strategy if padding is not False: if padding is True: __snake_case: Optional[int] = PaddingStrategy.LONGEST # Default to pad to the longest sequence in the batch elif not isinstance(A , A ): __snake_case: Optional[int] = PaddingStrategy(A ) elif isinstance(A , A ): __snake_case: Any = padding else: __snake_case: Any = PaddingStrategy.DO_NOT_PAD # Set max length if needed if max_length is None: if padding_strategy == PaddingStrategy.MAX_LENGTH: raise ValueError( f'''When setting ``padding={PaddingStrategy.MAX_LENGTH}``, make sure that max_length is defined''' ) # Test if we have a padding value if padding_strategy != PaddingStrategy.DO_NOT_PAD and (self.padding_value is None): raise ValueError( """Asking to pad but the feature_extractor does not have a padding value. Please select a value to use""" """ as `padding_value`. For example: `feature_extractor.padding_value = 0.0`.""" ) return padding_strategy
293
1
"""simple docstring""" from __future__ import annotations import pandas as pd def UpperCAmelCase__ ( lowerCAmelCase__ :list[int] , lowerCAmelCase__ :list[int] , lowerCAmelCase__ :int ) -> List[Any]: '''simple docstring''' lowercase = [0] * no_of_processes lowercase = [0] * no_of_processes # Copy the burst time into remaining_time[] for i in range(__lowerCamelCase ): lowercase = burst_time[i] lowercase = 0 lowercase = 0 lowercase = 9_9_9_9_9_9_9_9_9 lowercase = 0 lowercase = False # Process until all processes are completed while complete != no_of_processes: for j in range(__lowerCamelCase ): if arrival_time[j] <= increment_time and remaining_time[j] > 0: if remaining_time[j] < minm: lowercase = remaining_time[j] lowercase = j lowercase = True if not check: increment_time += 1 continue remaining_time[short] -= 1 lowercase = remaining_time[short] if minm == 0: lowercase = 9_9_9_9_9_9_9_9_9 if remaining_time[short] == 0: complete += 1 lowercase = False # Find finish time of current process lowercase = increment_time + 1 # Calculate waiting time lowercase = finish_time - arrival_time[short] lowercase = finar - burst_time[short] if waiting_time[short] < 0: lowercase = 0 # Increment time increment_time += 1 return waiting_time def UpperCAmelCase__ ( lowerCAmelCase__ :list[int] , lowerCAmelCase__ :int , lowerCAmelCase__ :list[int] ) -> str: '''simple docstring''' lowercase = [0] * no_of_processes for i in range(__lowerCamelCase ): lowercase = burst_time[i] + waiting_time[i] return turn_around_time def UpperCAmelCase__ ( lowerCAmelCase__ :list[int] , lowerCAmelCase__ :list[int] , lowerCAmelCase__ :int ) -> Optional[int]: '''simple docstring''' lowercase = 0 lowercase = 0 for i in range(__lowerCamelCase ): lowercase = total_waiting_time + waiting_time[i] lowercase = total_turn_around_time + turn_around_time[i] print(f'Average waiting time = {total_waiting_time / no_of_processes:.5f}' ) print("""Average turn around time =""" , total_turn_around_time / no_of_processes ) if __name__ == "__main__": print("""Enter how many process you want to analyze""") __lowerCAmelCase : List[str] =int(input()) __lowerCAmelCase : Union[str, Any] =[0] * no_of_processes __lowerCAmelCase : Dict =[0] * no_of_processes __lowerCAmelCase : Dict =list(range(1, no_of_processes + 1)) for i in range(no_of_processes): print("""Enter the arrival time and burst time for process:--""" + str(i + 1)) __lowerCAmelCase : Optional[Any] =map(int, input().split()) __lowerCAmelCase : int =calculate_waitingtime(arrival_time, burst_time, no_of_processes) __lowerCAmelCase : Dict =burst_time __lowerCAmelCase : Tuple =no_of_processes __lowerCAmelCase : Tuple =waiting_time __lowerCAmelCase : Tuple =calculate_turnaroundtime(bt, n, wt) calculate_average_times(waiting_time, turn_around_time, no_of_processes) __lowerCAmelCase : Any =pd.DataFrame( list(zip(processes, burst_time, arrival_time, waiting_time, turn_around_time)), columns=[ """Process""", """BurstTime""", """ArrivalTime""", """WaitingTime""", """TurnAroundTime""", ], ) # Printing the dataFrame pd.set_option("""display.max_rows""", fcfs.shape[0] + 1) print(fcfs)
197
"""simple docstring""" from typing import List, Optional, Tuple, Union import torch from ...utils import logging, randn_tensor from ..pipeline_utils import AudioPipelineOutput, DiffusionPipeline _lowercase : int = logging.get_logger(__name__) # pylint: disable=invalid-name class __SCREAMING_SNAKE_CASE ( lowerCAmelCase_ ): '''simple docstring''' def __init__( self : List[Any], lowerCamelCase : Union[str, Any], lowerCamelCase : Dict )-> Optional[int]: super().__init__() self.register_modules(unet=lowerCamelCase, scheduler=lowerCamelCase ) @torch.no_grad() def __call__( self : Optional[int], lowerCamelCase : int = 1, lowerCamelCase : int = 100, lowerCamelCase : Optional[Union[torch.Generator, List[torch.Generator]]] = None, lowerCamelCase : Optional[float] = None, lowerCamelCase : bool = True, )-> Union[AudioPipelineOutput, Tuple]: if audio_length_in_s is None: lowerCamelCase__ : int =self.unet.config.sample_size / self.unet.config.sample_rate lowerCamelCase__ : List[str] =audio_length_in_s * self.unet.config.sample_rate lowerCamelCase__ : Any =2 ** len(self.unet.up_blocks ) if sample_size < 3 * down_scale_factor: raise ValueError( F'''{audio_length_in_s} is too small. Make sure it\'s bigger or equal to''' F''' {3 * down_scale_factor / self.unet.config.sample_rate}.''' ) lowerCamelCase__ : Optional[int] =int(lowerCamelCase ) if sample_size % down_scale_factor != 0: lowerCamelCase__ : Tuple =( (audio_length_in_s * self.unet.config.sample_rate) // down_scale_factor + 1 ) * down_scale_factor logger.info( F'''{audio_length_in_s} is increased to {sample_size / self.unet.config.sample_rate} so that it can be handled''' F''' by the model. It will be cut to {original_sample_size / self.unet.config.sample_rate} after the denoising''' ''' process.''' ) lowerCamelCase__ : int =int(lowerCamelCase ) lowerCamelCase__ : str =next(iter(self.unet.parameters() ) ).dtype lowerCamelCase__ : Union[str, Any] =(batch_size, self.unet.config.in_channels, sample_size) if isinstance(lowerCamelCase, lowerCamelCase ) and len(lowerCamelCase ) != batch_size: raise ValueError( F'''You have passed a list of generators of length {len(lowerCamelCase )}, but requested an effective batch''' F''' size of {batch_size}. Make sure the batch size matches the length of the generators.''' ) lowerCamelCase__ : str =randn_tensor(lowerCamelCase, generator=lowerCamelCase, device=self.device, dtype=lowerCamelCase ) # set step values self.scheduler.set_timesteps(lowerCamelCase, device=audio.device ) lowerCamelCase__ : Any =self.scheduler.timesteps.to(lowerCamelCase ) for t in self.progress_bar(self.scheduler.timesteps ): # 1. predict noise model_output lowerCamelCase__ : str =self.unet(lowerCamelCase, lowerCamelCase ).sample # 2. compute previous image: x_t -> t_t-1 lowerCamelCase__ : Dict =self.scheduler.step(lowerCamelCase, lowerCamelCase, lowerCamelCase ).prev_sample lowerCamelCase__ : Optional[int] =audio.clamp(-1, 1 ).float().cpu().numpy() lowerCamelCase__ : List[Any] =audio[:, :, :original_sample_size] if not return_dict: return (audio,) return AudioPipelineOutput(audios=lowerCamelCase )
238
0
"""simple docstring""" import shutil import tempfile import unittest from unittest.mock import patch from transformers import ( DefaultFlowCallback, IntervalStrategy, PrinterCallback, ProgressCallback, Trainer, TrainerCallback, TrainingArguments, is_torch_available, ) from transformers.testing_utils import require_torch if is_torch_available(): from transformers.trainer import DEFAULT_CALLBACKS from .test_trainer import RegressionDataset, RegressionModelConfig, RegressionPreTrainedModel class _lowerCAmelCase ( lowercase ): """simple docstring""" def __init__( self : List[str] ): __lowercase = [] def _lowercase ( self : Optional[Any], UpperCAmelCase__ : Optional[Any], UpperCAmelCase__ : Tuple, UpperCAmelCase__ : List[str], **UpperCAmelCase__ : List[str] ): self.events.append("on_init_end" ) def _lowercase ( self : List[Any], UpperCAmelCase__ : Dict, UpperCAmelCase__ : List[Any], UpperCAmelCase__ : Optional[int], **UpperCAmelCase__ : int ): self.events.append("on_train_begin" ) def _lowercase ( self : Optional[Any], UpperCAmelCase__ : Any, UpperCAmelCase__ : Optional[Any], UpperCAmelCase__ : Dict, **UpperCAmelCase__ : int ): self.events.append("on_train_end" ) def _lowercase ( self : int, UpperCAmelCase__ : Tuple, UpperCAmelCase__ : Union[str, Any], UpperCAmelCase__ : int, **UpperCAmelCase__ : Any ): self.events.append("on_epoch_begin" ) def _lowercase ( self : int, UpperCAmelCase__ : Dict, UpperCAmelCase__ : int, UpperCAmelCase__ : int, **UpperCAmelCase__ : Optional[Any] ): self.events.append("on_epoch_end" ) def _lowercase ( self : Any, UpperCAmelCase__ : Tuple, UpperCAmelCase__ : Any, UpperCAmelCase__ : Union[str, Any], **UpperCAmelCase__ : Optional[int] ): self.events.append("on_step_begin" ) def _lowercase ( self : List[str], UpperCAmelCase__ : int, UpperCAmelCase__ : List[str], UpperCAmelCase__ : str, **UpperCAmelCase__ : List[Any] ): self.events.append("on_step_end" ) def _lowercase ( self : str, UpperCAmelCase__ : List[Any], UpperCAmelCase__ : List[str], UpperCAmelCase__ : Optional[int], **UpperCAmelCase__ : List[str] ): self.events.append("on_evaluate" ) def _lowercase ( self : int, UpperCAmelCase__ : Dict, UpperCAmelCase__ : List[str], UpperCAmelCase__ : Tuple, **UpperCAmelCase__ : Optional[int] ): self.events.append("on_predict" ) def _lowercase ( self : Optional[int], UpperCAmelCase__ : Any, UpperCAmelCase__ : List[Any], UpperCAmelCase__ : List[str], **UpperCAmelCase__ : List[Any] ): self.events.append("on_save" ) def _lowercase ( self : Optional[Any], UpperCAmelCase__ : List[Any], UpperCAmelCase__ : Union[str, Any], UpperCAmelCase__ : Dict, **UpperCAmelCase__ : Union[str, Any] ): self.events.append("on_log" ) def _lowercase ( self : Optional[int], UpperCAmelCase__ : str, UpperCAmelCase__ : Union[str, Any], UpperCAmelCase__ : Union[str, Any], **UpperCAmelCase__ : List[str] ): self.events.append("on_prediction_step" ) @require_torch class _lowerCAmelCase ( unittest.TestCase ): """simple docstring""" def _lowercase ( self : Optional[int] ): __lowercase = tempfile.mkdtemp() def _lowercase ( self : int ): shutil.rmtree(self.output_dir ) def _lowercase ( self : List[Any], UpperCAmelCase__ : str=0, UpperCAmelCase__ : Any=0, UpperCAmelCase__ : str=6_4, UpperCAmelCase__ : List[Any]=6_4, UpperCAmelCase__ : Union[str, Any]=None, UpperCAmelCase__ : Optional[int]=False, **UpperCAmelCase__ : List[str] ): # disable_tqdm in TrainingArguments has a flaky default since it depends on the level of logging. We make sure # its set to False since the tests later on depend on its value. __lowercase = RegressionDataset(length=UpperCAmelCase__ ) __lowercase = RegressionDataset(length=UpperCAmelCase__ ) __lowercase = RegressionModelConfig(a=UpperCAmelCase__, b=UpperCAmelCase__ ) __lowercase = RegressionPreTrainedModel(UpperCAmelCase__ ) __lowercase = TrainingArguments(self.output_dir, disable_tqdm=UpperCAmelCase__, report_to=[], **UpperCAmelCase__ ) return Trainer( UpperCAmelCase__, UpperCAmelCase__, train_dataset=UpperCAmelCase__, eval_dataset=UpperCAmelCase__, callbacks=UpperCAmelCase__, ) def _lowercase ( self : str, UpperCAmelCase__ : Any, UpperCAmelCase__ : Union[str, Any] ): self.assertEqual(len(UpperCAmelCase__ ), len(UpperCAmelCase__ ) ) # Order doesn't matter __lowercase = sorted(UpperCAmelCase__, key=lambda UpperCAmelCase__ : cb.__name__ if isinstance(UpperCAmelCase__, UpperCAmelCase__ ) else cb.__class__.__name__ ) __lowercase = sorted(UpperCAmelCase__, key=lambda UpperCAmelCase__ : cb.__name__ if isinstance(UpperCAmelCase__, UpperCAmelCase__ ) else cb.__class__.__name__ ) for cba, cba in zip(UpperCAmelCase__, UpperCAmelCase__ ): if isinstance(UpperCAmelCase__, UpperCAmelCase__ ) and isinstance(UpperCAmelCase__, UpperCAmelCase__ ): self.assertEqual(UpperCAmelCase__, UpperCAmelCase__ ) elif isinstance(UpperCAmelCase__, UpperCAmelCase__ ) and not isinstance(UpperCAmelCase__, UpperCAmelCase__ ): self.assertEqual(UpperCAmelCase__, cba.__class__ ) elif not isinstance(UpperCAmelCase__, UpperCAmelCase__ ) and isinstance(UpperCAmelCase__, UpperCAmelCase__ ): self.assertEqual(cba.__class__, UpperCAmelCase__ ) else: self.assertEqual(UpperCAmelCase__, UpperCAmelCase__ ) def _lowercase ( self : Dict, UpperCAmelCase__ : Any ): __lowercase = ["on_init_end", "on_train_begin"] __lowercase = 0 __lowercase = len(trainer.get_eval_dataloader() ) __lowercase = ["on_prediction_step"] * len(trainer.get_eval_dataloader() ) + ["on_log", "on_evaluate"] for _ in range(trainer.state.num_train_epochs ): expected_events.append("on_epoch_begin" ) for _ in range(UpperCAmelCase__ ): step += 1 expected_events += ["on_step_begin", "on_step_end"] if step % trainer.args.logging_steps == 0: expected_events.append("on_log" ) if trainer.args.evaluation_strategy == IntervalStrategy.STEPS and step % trainer.args.eval_steps == 0: expected_events += evaluation_events.copy() if step % trainer.args.save_steps == 0: expected_events.append("on_save" ) expected_events.append("on_epoch_end" ) if trainer.args.evaluation_strategy == IntervalStrategy.EPOCH: expected_events += evaluation_events.copy() expected_events += ["on_log", "on_train_end"] return expected_events def _lowercase ( self : Tuple ): __lowercase = self.get_trainer() __lowercase = DEFAULT_CALLBACKS.copy() + [ProgressCallback] self.check_callbacks_equality(trainer.callback_handler.callbacks, UpperCAmelCase__ ) # Callbacks passed at init are added to the default callbacks __lowercase = self.get_trainer(callbacks=[MyTestTrainerCallback] ) expected_callbacks.append(UpperCAmelCase__ ) self.check_callbacks_equality(trainer.callback_handler.callbacks, UpperCAmelCase__ ) # TrainingArguments.disable_tqdm controls if use ProgressCallback or PrinterCallback __lowercase = self.get_trainer(disable_tqdm=UpperCAmelCase__ ) __lowercase = DEFAULT_CALLBACKS.copy() + [PrinterCallback] self.check_callbacks_equality(trainer.callback_handler.callbacks, UpperCAmelCase__ ) def _lowercase ( self : Union[str, Any] ): __lowercase = DEFAULT_CALLBACKS.copy() + [ProgressCallback] __lowercase = self.get_trainer() # We can add, pop, or remove by class name trainer.remove_callback(UpperCAmelCase__ ) expected_callbacks.remove(UpperCAmelCase__ ) self.check_callbacks_equality(trainer.callback_handler.callbacks, UpperCAmelCase__ ) __lowercase = self.get_trainer() __lowercase = trainer.pop_callback(UpperCAmelCase__ ) self.assertEqual(cb.__class__, UpperCAmelCase__ ) self.check_callbacks_equality(trainer.callback_handler.callbacks, UpperCAmelCase__ ) trainer.add_callback(UpperCAmelCase__ ) expected_callbacks.insert(0, UpperCAmelCase__ ) self.check_callbacks_equality(trainer.callback_handler.callbacks, UpperCAmelCase__ ) # We can also add, pop, or remove by instance __lowercase = self.get_trainer() __lowercase = trainer.callback_handler.callbacks[0] trainer.remove_callback(UpperCAmelCase__ ) expected_callbacks.remove(UpperCAmelCase__ ) self.check_callbacks_equality(trainer.callback_handler.callbacks, UpperCAmelCase__ ) __lowercase = self.get_trainer() __lowercase = trainer.callback_handler.callbacks[0] __lowercase = trainer.pop_callback(UpperCAmelCase__ ) self.assertEqual(UpperCAmelCase__, UpperCAmelCase__ ) self.check_callbacks_equality(trainer.callback_handler.callbacks, UpperCAmelCase__ ) trainer.add_callback(UpperCAmelCase__ ) expected_callbacks.insert(0, UpperCAmelCase__ ) self.check_callbacks_equality(trainer.callback_handler.callbacks, UpperCAmelCase__ ) def _lowercase ( self : Any ): import warnings # XXX: for now ignore scatter_gather warnings in this test since it's not relevant to what's being tested warnings.simplefilter(action="ignore", category=UpperCAmelCase__ ) __lowercase = self.get_trainer(callbacks=[MyTestTrainerCallback] ) trainer.train() __lowercase = trainer.callback_handler.callbacks[-2].events self.assertEqual(UpperCAmelCase__, self.get_expected_events(UpperCAmelCase__ ) ) # Independent log/save/eval __lowercase = self.get_trainer(callbacks=[MyTestTrainerCallback], logging_steps=5 ) trainer.train() __lowercase = trainer.callback_handler.callbacks[-2].events self.assertEqual(UpperCAmelCase__, self.get_expected_events(UpperCAmelCase__ ) ) __lowercase = self.get_trainer(callbacks=[MyTestTrainerCallback], save_steps=5 ) trainer.train() __lowercase = trainer.callback_handler.callbacks[-2].events self.assertEqual(UpperCAmelCase__, self.get_expected_events(UpperCAmelCase__ ) ) __lowercase = self.get_trainer(callbacks=[MyTestTrainerCallback], eval_steps=5, evaluation_strategy="steps" ) trainer.train() __lowercase = trainer.callback_handler.callbacks[-2].events self.assertEqual(UpperCAmelCase__, self.get_expected_events(UpperCAmelCase__ ) ) __lowercase = self.get_trainer(callbacks=[MyTestTrainerCallback], evaluation_strategy="epoch" ) trainer.train() __lowercase = trainer.callback_handler.callbacks[-2].events self.assertEqual(UpperCAmelCase__, self.get_expected_events(UpperCAmelCase__ ) ) # A bit of everything __lowercase = self.get_trainer( callbacks=[MyTestTrainerCallback], logging_steps=3, save_steps=1_0, eval_steps=5, evaluation_strategy="steps", ) trainer.train() __lowercase = trainer.callback_handler.callbacks[-2].events self.assertEqual(UpperCAmelCase__, self.get_expected_events(UpperCAmelCase__ ) ) # warning should be emitted for duplicated callbacks with patch("transformers.trainer_callback.logger.warning" ) as warn_mock: __lowercase = self.get_trainer( callbacks=[MyTestTrainerCallback, MyTestTrainerCallback], ) assert str(UpperCAmelCase__ ) in warn_mock.call_args[0][0]
144
"""simple docstring""" _a = [ 'DownloadConfig', 'DownloadManager', 'DownloadMode', 'StreamingDownloadManager', ] from .download_config import DownloadConfig from .download_manager import DownloadManager, DownloadMode from .streaming_download_manager import StreamingDownloadManager
144
1
from typing import Dict, Optional, Union import numpy as np from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict from ...image_transforms import flip_channel_order, resize, to_channel_dimension_format, to_pil_image from ...image_utils import ( ChannelDimension, ImageInput, PILImageResampling, make_list_of_images, to_numpy_array, valid_images, ) from ...utils import TensorType, is_pytesseract_available, is_vision_available, logging, requires_backends if is_vision_available(): import PIL # soft dependency if is_pytesseract_available(): import pytesseract __lowerCAmelCase : List[Any] = logging.get_logger(__name__) def UpperCAmelCase_ ( __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase ) -> Tuple: return [ int(1_000 * (box[0] / width) ), int(1_000 * (box[1] / height) ), int(1_000 * (box[2] / width) ), int(1_000 * (box[3] / height) ), ] def UpperCAmelCase_ ( __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase = None ) -> List[str]: __lowercase : Optional[int] = tesseract_config if tesseract_config is not None else '''''' # apply OCR __lowercase : Union[str, Any] = to_pil_image(__lowerCAmelCase ) __lowercase , __lowercase : Any = pil_image.size __lowercase : Union[str, Any] = pytesseract.image_to_data(__lowerCAmelCase , lang=__lowerCAmelCase , output_type='''dict''' , config=__lowerCAmelCase ) __lowercase , __lowercase , __lowercase , __lowercase , __lowercase : int = data['''text'''], data['''left'''], data['''top'''], data['''width'''], data['''height'''] # filter empty words and corresponding coordinates __lowercase : str = [idx for idx, word in enumerate(__lowerCAmelCase ) if not word.strip()] __lowercase : List[Any] = [word for idx, word in enumerate(__lowerCAmelCase ) if idx not in irrelevant_indices] __lowercase : Tuple = [coord for idx, coord in enumerate(__lowerCAmelCase ) if idx not in irrelevant_indices] __lowercase : Any = [coord for idx, coord in enumerate(__lowerCAmelCase ) if idx not in irrelevant_indices] __lowercase : str = [coord for idx, coord in enumerate(__lowerCAmelCase ) if idx not in irrelevant_indices] __lowercase : str = [coord for idx, coord in enumerate(__lowerCAmelCase ) if idx not in irrelevant_indices] # turn coordinates into (left, top, left+width, top+height) format __lowercase : List[Any] = [] for x, y, w, h in zip(__lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase ): __lowercase : int = [x, y, x + w, y + h] actual_boxes.append(__lowerCAmelCase ) # finally, normalize the bounding boxes __lowercase : str = [] for box in actual_boxes: normalized_boxes.append(normalize_box(__lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase ) ) assert len(__lowerCAmelCase ) == len(__lowerCAmelCase ), "Not as many words as there are bounding boxes" return words, normalized_boxes class __lowerCAmelCase ( lowerCAmelCase_ ): """simple docstring""" A__ : Dict = ['''pixel_values'''] def __init__( self : str , _snake_case : bool = True , _snake_case : Dict[str, int] = None , _snake_case : PILImageResampling = PILImageResampling.BILINEAR , _snake_case : bool = True , _snake_case : Optional[str] = None , _snake_case : Optional[str] = "" , **_snake_case : Union[str, Any] , ): super().__init__(**_snake_case ) __lowercase : Optional[int] = size if size is not None else {'''height''': 224, '''width''': 224} __lowercase : Optional[int] = get_size_dict(_snake_case ) __lowercase : Optional[int] = do_resize __lowercase : List[str] = size __lowercase : Optional[Any] = resample __lowercase : str = apply_ocr __lowercase : List[Any] = ocr_lang __lowercase : Optional[int] = tesseract_config def snake_case_ ( self : str , _snake_case : np.ndarray , _snake_case : Dict[str, int] , _snake_case : PILImageResampling = PILImageResampling.BILINEAR , _snake_case : Optional[Union[str, ChannelDimension]] = None , **_snake_case : Any , ): __lowercase : Optional[Any] = get_size_dict(_snake_case ) if "height" not in size or "width" not in size: raise ValueError(F'The size dictionary must contain the keys \'height\' and \'width\'. Got {size.keys()}' ) __lowercase : Dict = (size['''height'''], size['''width''']) return resize(_snake_case , size=_snake_case , resample=_snake_case , data_format=_snake_case , **_snake_case ) def snake_case_ ( self : int , _snake_case : ImageInput , _snake_case : bool = None , _snake_case : Dict[str, int] = None , _snake_case : PILImageResampling = None , _snake_case : bool = None , _snake_case : Optional[str] = None , _snake_case : Optional[str] = None , _snake_case : Optional[Union[str, TensorType]] = None , _snake_case : ChannelDimension = ChannelDimension.FIRST , **_snake_case : Optional[int] , ): __lowercase : str = do_resize if do_resize is not None else self.do_resize __lowercase : int = size if size is not None else self.size __lowercase : Dict = get_size_dict(_snake_case ) __lowercase : Union[str, Any] = resample if resample is not None else self.resample __lowercase : int = apply_ocr if apply_ocr is not None else self.apply_ocr __lowercase : List[str] = ocr_lang if ocr_lang is not None else self.ocr_lang __lowercase : Union[str, Any] = tesseract_config if tesseract_config is not None else self.tesseract_config __lowercase : Union[str, Any] = make_list_of_images(_snake_case ) if not valid_images(_snake_case ): raise ValueError( '''Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, ''' '''torch.Tensor, tf.Tensor or jax.ndarray.''' ) if do_resize and size is None: raise ValueError('''Size must be specified if do_resize is True.''' ) # All transformations expect numpy arrays. __lowercase : Optional[int] = [to_numpy_array(_snake_case ) for image in images] if apply_ocr: requires_backends(self , '''pytesseract''' ) __lowercase : Optional[int] = [] __lowercase : Tuple = [] for image in images: __lowercase , __lowercase : Dict = apply_tesseract(_snake_case , _snake_case , _snake_case ) words_batch.append(_snake_case ) boxes_batch.append(_snake_case ) if do_resize: __lowercase : int = [self.resize(image=_snake_case , size=_snake_case , resample=_snake_case ) for image in images] # flip color channels from RGB to BGR (as Detectron2 requires this) __lowercase : Tuple = [flip_channel_order(_snake_case ) for image in images] __lowercase : int = [to_channel_dimension_format(_snake_case , _snake_case ) for image in images] __lowercase : Optional[Any] = BatchFeature(data={'''pixel_values''': images} , tensor_type=_snake_case ) if apply_ocr: __lowercase : str = words_batch __lowercase : int = boxes_batch return data
156
from __future__ import annotations from PIL import Image # Define glider example __lowerCAmelCase : Optional[int] = [ [0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0], [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], ] # Define blinker example __lowerCAmelCase : Union[str, Any] = [[0, 1, 0], [0, 1, 0], [0, 1, 0]] def UpperCAmelCase_ ( __lowerCAmelCase ) -> list[list[int]]: __lowercase : int = [] for i in range(len(__lowerCAmelCase ) ): __lowercase : Optional[int] = [] for j in range(len(cells[i] ) ): # Get the number of live neighbours __lowercase : Union[str, Any] = 0 if i > 0 and j > 0: neighbour_count += cells[i - 1][j - 1] if i > 0: neighbour_count += cells[i - 1][j] if i > 0 and j < len(cells[i] ) - 1: neighbour_count += cells[i - 1][j + 1] if j > 0: neighbour_count += cells[i][j - 1] if j < len(cells[i] ) - 1: neighbour_count += cells[i][j + 1] if i < len(__lowerCAmelCase ) - 1 and j > 0: neighbour_count += cells[i + 1][j - 1] if i < len(__lowerCAmelCase ) - 1: neighbour_count += cells[i + 1][j] if i < len(__lowerCAmelCase ) - 1 and j < len(cells[i] ) - 1: neighbour_count += cells[i + 1][j + 1] # Rules of the game of life (excerpt from Wikipedia): # 1. Any live cell with two or three live neighbours survives. # 2. Any dead cell with three live neighbours becomes a live cell. # 3. All other live cells die in the next generation. # Similarly, all other dead cells stay dead. __lowercase : List[Any] = cells[i][j] == 1 if ( (alive and 2 <= neighbour_count <= 3) or not alive and neighbour_count == 3 ): next_generation_row.append(1 ) else: next_generation_row.append(0 ) next_generation.append(__lowerCAmelCase ) return next_generation def UpperCAmelCase_ ( __lowerCAmelCase , __lowerCAmelCase ) -> list[Image.Image]: __lowercase : Tuple = [] for _ in range(__lowerCAmelCase ): # Create output image __lowercase : Tuple = Image.new('''RGB''' , (len(cells[0] ), len(__lowerCAmelCase )) ) __lowercase : Dict = img.load() # Save cells to image for x in range(len(__lowerCAmelCase ) ): for y in range(len(cells[0] ) ): __lowercase : int = 255 - cells[y][x] * 255 __lowercase : Tuple = (colour, colour, colour) # Save image images.append(__lowerCAmelCase ) __lowercase : Tuple = new_generation(__lowerCAmelCase ) return images if __name__ == "__main__": __lowerCAmelCase : Any = generate_images(GLIDER, 16) images[0].save("out.gif", save_all=True, append_images=images[1:])
156
1
import argparse import json import re from pathlib import Path import requests import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import ( MobileNetVaConfig, MobileNetVaForImageClassification, MobileNetVaImageProcessor, load_tf_weights_in_mobilenet_va, ) from transformers.utils import logging logging.set_verbosity_info() A__ : List[Any] = logging.get_logger(__name__) def _snake_case ( lowerCamelCase__ : int ) -> Union[str, Any]: lowerCamelCase_ : int =MobileNetVaConfig(layer_norm_eps=0.001 ) if "_quant" in model_name: raise ValueError("Quantized models are not supported." ) lowerCamelCase_ : List[Any] =re.match(r"^mobilenet_v1_([^_]*)_([^_]*)$" , __lowerCamelCase ) if matches: lowerCamelCase_ : List[Any] =float(matches[1] ) lowerCamelCase_ : Any =int(matches[2] ) # The TensorFlow version of MobileNetV1 predicts 1001 classes instead of # the usual 1000. The first class (index 0) is "background". lowerCamelCase_ : Dict =1_001 lowerCamelCase_ : Any ="imagenet-1k-id2label.json" lowerCamelCase_ : Optional[Any] ="huggingface/label-files" lowerCamelCase_ : Any =json.load(open(hf_hub_download(__lowerCamelCase , __lowerCamelCase , repo_type="dataset" ) , "r" ) ) lowerCamelCase_ : int ={int(__lowerCamelCase ) + 1: v for k, v in idalabel.items()} lowerCamelCase_ : Tuple ="background" lowerCamelCase_ : Optional[int] =idalabel lowerCamelCase_ : Dict ={v: k for k, v in idalabel.items()} return config def _snake_case ( ) -> List[Any]: lowerCamelCase_ : Dict ="http://images.cocodataset.org/val2017/000000039769.jpg" lowerCamelCase_ : Union[str, Any] =Image.open(requests.get(__lowerCamelCase , stream=__lowerCamelCase ).raw ) return im @torch.no_grad() def _snake_case ( lowerCamelCase__ : List[Any] , lowerCamelCase__ : Any , lowerCamelCase__ : int , lowerCamelCase__ : int=False ) -> List[str]: lowerCamelCase_ : Optional[Any] =get_mobilenet_va_config(__lowerCamelCase ) # Load 🤗 model lowerCamelCase_ : Optional[Any] =MobileNetVaForImageClassification(__lowerCamelCase ).eval() # Load weights from TensorFlow checkpoint load_tf_weights_in_mobilenet_va(__lowerCamelCase , __lowerCamelCase , __lowerCamelCase ) # Check outputs on an image, prepared by MobileNetV1ImageProcessor lowerCamelCase_ : Any =MobileNetVaImageProcessor( crop_size={"width": config.image_size, "height": config.image_size} , size={"shortest_edge": config.image_size + 32} , ) lowerCamelCase_ : Dict =image_processor(images=prepare_img() , return_tensors="pt" ) lowerCamelCase_ : str =model(**__lowerCamelCase ) lowerCamelCase_ : Dict =outputs.logits assert logits.shape == (1, 1_001) if model_name == "mobilenet_v1_1.0_224": lowerCamelCase_ : Union[str, Any] =torch.tensor([-4.1739, -1.1233, 3.1205] ) elif model_name == "mobilenet_v1_0.75_192": lowerCamelCase_ : Optional[int] =torch.tensor([-3.9440, -2.3141, -0.3333] ) else: lowerCamelCase_ : Optional[Any] =None if expected_logits is not None: assert torch.allclose(logits[0, :3] , __lowerCamelCase , atol=1e-4 ) Path(__lowerCamelCase ).mkdir(exist_ok=__lowerCamelCase ) print(F"""Saving model {model_name} to {pytorch_dump_folder_path}""" ) model.save_pretrained(__lowerCamelCase ) print(F"""Saving image processor to {pytorch_dump_folder_path}""" ) image_processor.save_pretrained(__lowerCamelCase ) if push_to_hub: print("Pushing to the hub..." ) lowerCamelCase_ : str ="google/" + model_name image_processor.push_to_hub(__lowerCamelCase ) model.push_to_hub(__lowerCamelCase ) if __name__ == "__main__": A__ : Union[str, Any] = argparse.ArgumentParser() # Required parameters parser.add_argument( '--model_name', default='mobilenet_v1_1.0_224', type=str, help='Name of the MobileNetV1 model you\'d like to convert. Should in the form \'mobilenet_v1_<depth>_<size>\'.', ) parser.add_argument( '--checkpoint_path', required=True, type=str, help='Path to the original TensorFlow checkpoint (.ckpt file).' ) parser.add_argument( '--pytorch_dump_folder_path', required=True, type=str, help='Path to the output PyTorch model directory.' ) parser.add_argument( '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.' ) A__ : Optional[int] = parser.parse_args() convert_movilevit_checkpoint( args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub )
360
"""simple docstring""" import inspect import unittest from transformers import DecisionTransformerConfig, is_torch_available from transformers.testing_utils import require_torch, slow, torch_device from ...generation.test_utils import GenerationTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import DecisionTransformerModel from transformers.models.decision_transformer.modeling_decision_transformer import ( DECISION_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, ) class lowercase__ : def __init__( self : List[Any] , snake_case__ : Optional[Any] , snake_case__ : Tuple=13 , snake_case__ : str=7 , snake_case__ : Union[str, Any]=6 , snake_case__ : str=17 , snake_case__ : Any=23 , snake_case__ : int=11 , snake_case__ : Tuple=True , ): lowerCamelCase_ : str =parent lowerCamelCase_ : Union[str, Any] =batch_size lowerCamelCase_ : List[Any] =seq_length lowerCamelCase_ : Union[str, Any] =act_dim lowerCamelCase_ : Optional[Any] =state_dim lowerCamelCase_ : Optional[Any] =hidden_size lowerCamelCase_ : Tuple =max_length lowerCamelCase_ : List[Any] =is_training def UpperCAmelCase__ ( self : Dict ): lowerCamelCase_ : Optional[Any] =floats_tensor((self.batch_size, self.seq_length, self.state_dim) ) lowerCamelCase_ : Optional[Any] =floats_tensor((self.batch_size, self.seq_length, self.act_dim) ) lowerCamelCase_ : List[Any] =floats_tensor((self.batch_size, self.seq_length, 1) ) lowerCamelCase_ : Optional[Any] =floats_tensor((self.batch_size, self.seq_length, 1) ) lowerCamelCase_ : List[Any] =ids_tensor((self.batch_size, self.seq_length) , vocab_size=1000 ) lowerCamelCase_ : Optional[int] =random_attention_mask((self.batch_size, self.seq_length) ) lowerCamelCase_ : List[str] =self.get_config() return ( config, states, actions, rewards, returns_to_go, timesteps, attention_mask, ) def UpperCAmelCase__ ( self : Any ): return DecisionTransformerConfig( batch_size=self.batch_size , seq_length=self.seq_length , act_dim=self.act_dim , state_dim=self.state_dim , hidden_size=self.hidden_size , max_length=self.max_length , ) def UpperCAmelCase__ ( self : Optional[Any] , snake_case__ : Tuple , snake_case__ : Dict , snake_case__ : int , snake_case__ : Dict , snake_case__ : Optional[int] , snake_case__ : List[str] , snake_case__ : List[str] , ): lowerCamelCase_ : Tuple =DecisionTransformerModel(config=snake_case__ ) model.to(snake_case__ ) model.eval() lowerCamelCase_ : str =model(snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ ) self.parent.assertEqual(result.state_preds.shape , states.shape ) self.parent.assertEqual(result.action_preds.shape , actions.shape ) self.parent.assertEqual(result.return_preds.shape , returns_to_go.shape ) self.parent.assertEqual( result.last_hidden_state.shape , (self.batch_size, self.seq_length * 3, self.hidden_size) ) # seq length *3 as there are 3 modelities: states, returns and actions def UpperCAmelCase__ ( self : List[str] ): lowerCamelCase_ : List[str] =self.prepare_config_and_inputs() ( ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ) : Optional[int] =config_and_inputs lowerCamelCase_ : Optional[int] ={ "states": states, "actions": actions, "rewards": rewards, "returns_to_go": returns_to_go, "timesteps": timesteps, "attention_mask": attention_mask, } return config, inputs_dict @require_torch class lowercase__ ( snake_case__, snake_case__, snake_case__, unittest.TestCase ): _UpperCAmelCase :Optional[Any] = (DecisionTransformerModel,) if is_torch_available() else () _UpperCAmelCase :int = () _UpperCAmelCase :int = {"feature-extraction": DecisionTransformerModel} if is_torch_available() else {} # Ignoring of a failing test from GenerationTesterMixin, as the model does not use inputs_ids _UpperCAmelCase :Union[str, Any] = False # Ignoring of a failing tests from ModelTesterMixin, as the model does not implement these features _UpperCAmelCase :Optional[Any] = False _UpperCAmelCase :Tuple = False _UpperCAmelCase :Tuple = False _UpperCAmelCase :List[Any] = False _UpperCAmelCase :Dict = False _UpperCAmelCase :Any = False _UpperCAmelCase :List[Any] = False _UpperCAmelCase :int = False _UpperCAmelCase :str = False def UpperCAmelCase__ ( self : str ): lowerCamelCase_ : Dict =DecisionTransformerModelTester(self ) lowerCamelCase_ : str =ConfigTester(self , config_class=snake_case__ , hidden_size=37 ) def UpperCAmelCase__ ( self : Union[str, Any] ): self.config_tester.run_common_tests() def UpperCAmelCase__ ( self : int ): lowerCamelCase_ : Tuple =self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*snake_case__ ) @slow def UpperCAmelCase__ ( self : List[str] ): for model_name in DECISION_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: lowerCamelCase_ : str =DecisionTransformerModel.from_pretrained(snake_case__ ) self.assertIsNotNone(snake_case__ ) def UpperCAmelCase__ ( self : str ): lowerCamelCase_ , lowerCamelCase_ : Dict =self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: lowerCamelCase_ : List[Any] =model_class(snake_case__ ) lowerCamelCase_ : int =inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic lowerCamelCase_ : List[Any] =[*signature.parameters.keys()] lowerCamelCase_ : List[str] =[ "states", "actions", "rewards", "returns_to_go", "timesteps", "attention_mask", ] self.assertListEqual(arg_names[: len(snake_case__ )] , snake_case__ ) @require_torch class lowercase__ ( unittest.TestCase ): @slow def UpperCAmelCase__ ( self : Any ): lowerCamelCase_ : Optional[int] =2 # number of steps of autoregressive prediction we will perform lowerCamelCase_ : int =10 # defined by the RL environment, may be normalized lowerCamelCase_ : List[Any] =DecisionTransformerModel.from_pretrained("edbeeching/decision-transformer-gym-hopper-expert" ) lowerCamelCase_ : Union[str, Any] =model.to(snake_case__ ) lowerCamelCase_ : Any =model.config torch.manual_seed(0 ) lowerCamelCase_ : Optional[Any] =torch.randn(1 , 1 , config.state_dim ).to(device=snake_case__ , dtype=torch.floataa ) # env.reset() lowerCamelCase_ : Optional[Any] =torch.tensor( [[0.242_793, -0.28_693_074, 0.8_742_613], [0.67_815_274, -0.08_101_085, -0.12_952_147]] , device=snake_case__ ) lowerCamelCase_ : int =torch.tensor(snake_case__ , device=snake_case__ , dtype=torch.floataa ).reshape(1 , 1 , 1 ) lowerCamelCase_ : str =state lowerCamelCase_ : Optional[int] =torch.zeros(1 , 0 , config.act_dim , device=snake_case__ , dtype=torch.floataa ) lowerCamelCase_ : int =torch.zeros(1 , 0 , device=snake_case__ , dtype=torch.floataa ) lowerCamelCase_ : Tuple =torch.tensor(0 , device=snake_case__ , dtype=torch.long ).reshape(1 , 1 ) for step in range(snake_case__ ): lowerCamelCase_ : str =torch.cat([actions, torch.zeros(1 , 1 , config.act_dim , device=snake_case__ )] , dim=1 ) lowerCamelCase_ : Union[str, Any] =torch.cat([rewards, torch.zeros(1 , 1 , device=snake_case__ )] , dim=1 ) lowerCamelCase_ : Optional[int] =torch.ones(1 , states.shape[1] ).to(dtype=torch.long , device=states.device ) with torch.no_grad(): lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ : Dict =model( states=snake_case__ , actions=snake_case__ , rewards=snake_case__ , returns_to_go=snake_case__ , timesteps=snake_case__ , attention_mask=snake_case__ , return_dict=snake_case__ , ) self.assertEqual(action_pred.shape , actions.shape ) self.assertTrue(torch.allclose(action_pred[0, -1] , expected_outputs[step] , atol=1E-4 ) ) lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ : Optional[Any] =( # env.step(action) torch.randn(1 , 1 , config.state_dim ).to(device=snake_case__ , dtype=torch.floataa ), 1.0, False, {}, ) lowerCamelCase_ : str =action_pred[0, -1] lowerCamelCase_ : Optional[int] =torch.cat([states, state] , dim=1 ) lowerCamelCase_ : Optional[Any] =returns_to_go[0, -1] - reward lowerCamelCase_ : str =torch.cat([returns_to_go, pred_return.reshape(1 , 1 , 1 )] , dim=1 ) lowerCamelCase_ : int =torch.cat( [timesteps, torch.ones((1, 1) , device=snake_case__ , dtype=torch.long ) * (step + 1)] , dim=1 )
209
0
"""simple docstring""" import argparse import hashlib # hashlib is only used inside the Test class import struct class lowercase: '''simple docstring''' def __init__( self: List[Any], a_: List[str] ): '''simple docstring''' _snake_case : int = data _snake_case : Dict = [0X67452301, 0Xefcdab89, 0X98badcfe, 0X10325476, 0Xc3d2e1f0] @staticmethod def UpperCamelCase_ ( a_: Optional[Any], a_: Dict ): '''simple docstring''' return ((n << b) | (n >> (32 - b))) & 0Xffffffff def UpperCamelCase_ ( self: List[Any] ): '''simple docstring''' _snake_case : Union[str, Any] = B"""\x80""" + B"""\x00""" * (63 - (len(self.data ) + 8) % 64) _snake_case : Optional[int] = self.data + padding + struct.pack(""">Q""", 8 * len(self.data ) ) return padded_data def UpperCamelCase_ ( self: Union[str, Any] ): '''simple docstring''' return [ self.padded_data[i : i + 64] for i in range(0, len(self.padded_data ), 64 ) ] def UpperCamelCase_ ( self: Optional[Any], a_: List[Any] ): '''simple docstring''' _snake_case : List[str] = list(struct.unpack(""">16L""", a_ ) ) + [0] * 64 for i in range(16, 80 ): _snake_case : List[Any] = self.rotate((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]), 1 ) return w def UpperCamelCase_ ( self: int ): '''simple docstring''' _snake_case : Union[str, Any] = self.padding() _snake_case : str = self.split_blocks() for block in self.blocks: _snake_case : Any = self.expand_block(a_ ) _snake_case , _snake_case , _snake_case , _snake_case , _snake_case : Optional[int] = self.h for i in range(0, 80 ): if 0 <= i < 20: _snake_case : int = (b & c) | ((~b) & d) _snake_case : str = 0X5a827999 elif 20 <= i < 40: _snake_case : Optional[int] = b ^ c ^ d _snake_case : str = 0X6ed9eba1 elif 40 <= i < 60: _snake_case : List[Any] = (b & c) | (b & d) | (c & d) _snake_case : List[Any] = 0X8f1bbcdc elif 60 <= i < 80: _snake_case : List[Any] = b ^ c ^ d _snake_case : int = 0Xca62c1d6 _snake_case , _snake_case , _snake_case , _snake_case , _snake_case : Optional[int] = ( self.rotate(a_, 5 ) + f + e + k + expanded_block[i] & 0Xffffffff, a, self.rotate(a_, 30 ), c, d, ) _snake_case : Union[str, Any] = ( self.h[0] + a & 0Xffffffff, self.h[1] + b & 0Xffffffff, self.h[2] + c & 0Xffffffff, self.h[3] + d & 0Xffffffff, self.h[4] + e & 0Xffffffff, ) return ("{:08x}" * 5).format(*self.h ) def UpperCAmelCase__ (): """simple docstring""" _snake_case : Any = B"""Test String""" assert SHAaHash(snake_case__ ).final_hash() == hashlib.shaa(snake_case__ ).hexdigest() # noqa: S324 def UpperCAmelCase__ (): """simple docstring""" _snake_case : List[Any] = argparse.ArgumentParser(description="""Process some strings or files""" ) parser.add_argument( """--string""" , dest="""input_string""" , default="""Hello World!! Welcome to Cryptography""" , help="""Hash the string""" , ) parser.add_argument("""--file""" , dest="""input_file""" , help="""Hash contents of a file""" ) _snake_case : Union[str, Any] = parser.parse_args() _snake_case : List[Any] = args.input_string # In any case hash input should be a bytestring if args.input_file: with open(args.input_file , """rb""" ) as f: _snake_case : str = f.read() else: _snake_case : int = bytes(snake_case__ , """utf-8""" ) print(SHAaHash(snake_case__ ).final_hash() ) if __name__ == "__main__": main() import doctest doctest.testmod()
64
"""simple docstring""" import unittest import numpy as np from diffusers import OnnxStableDiffusionInpaintPipelineLegacy from diffusers.utils.testing_utils import ( is_onnx_available, load_image, load_numpy, nightly, require_onnxruntime, require_torch_gpu, ) if is_onnx_available(): import onnxruntime as ort @nightly @require_onnxruntime @require_torch_gpu class lowercase( unittest.TestCase ): '''simple docstring''' @property def UpperCamelCase_ ( self: Optional[Any] ): '''simple docstring''' return ( "CUDAExecutionProvider", { "gpu_mem_limit": "15000000000", # 15GB "arena_extend_strategy": "kSameAsRequested", }, ) @property def UpperCamelCase_ ( self: int ): '''simple docstring''' _snake_case : Any = ort.SessionOptions() _snake_case : Union[str, Any] = False return options def UpperCamelCase_ ( self: List[Any] ): '''simple docstring''' _snake_case : Any = load_image( """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main""" """/in_paint/overture-creations-5sI6fQgYIuo.png""" ) _snake_case : Union[str, Any] = load_image( """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main""" """/in_paint/overture-creations-5sI6fQgYIuo_mask.png""" ) _snake_case : Union[str, Any] = load_numpy( """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main""" """/in_paint/red_cat_sitting_on_a_park_bench_onnx.npy""" ) # using the PNDM scheduler by default _snake_case : Optional[Any] = OnnxStableDiffusionInpaintPipelineLegacy.from_pretrained( """CompVis/stable-diffusion-v1-4""", revision="""onnx""", safety_checker=a_, feature_extractor=a_, provider=self.gpu_provider, sess_options=self.gpu_options, ) pipe.set_progress_bar_config(disable=a_ ) _snake_case : Optional[Any] = """A red cat sitting on a park bench""" _snake_case : Optional[int] = np.random.RandomState(0 ) _snake_case : Any = pipe( prompt=a_, image=a_, mask_image=a_, strength=0.75, guidance_scale=7.5, num_inference_steps=15, generator=a_, output_type="""np""", ) _snake_case : Dict = output.images[0] assert image.shape == (512, 512, 3) assert np.abs(expected_image - image ).max() < 1E-2
64
1
"""simple docstring""" from __future__ import annotations import time from math import sqrt # 1 for manhattan, 0 for euclidean __UpperCamelCase : Dict = 0 __UpperCamelCase : Optional[Any] = [ [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 : Union[str, Any] = [[-1, 0], [0, -1], [1, 0], [0, 1]] # up, left, down, right __UpperCamelCase : Any = tuple[int, int] class a : def __init__( self , _snake_case , _snake_case , _snake_case , _snake_case , _snake_case , _snake_case , ): """simple docstring""" lowerCAmelCase = pos_x lowerCAmelCase = pos_y lowerCAmelCase = (pos_y, pos_x) lowerCAmelCase = goal_x lowerCAmelCase = goal_y lowerCAmelCase = g_cost lowerCAmelCase = parent lowerCAmelCase = self.calculate_heuristic() lowerCAmelCase = self.g_cost + self.h_cost def UpperCamelCase__ ( self ): """simple docstring""" lowerCAmelCase = self.pos_x - self.goal_x lowerCAmelCase = self.pos_y - self.goal_y if HEURISTIC == 1: return abs(_snake_case ) + abs(_snake_case ) else: return sqrt(dy**2 + dx**2 ) def __lt__( self , _snake_case ): """simple docstring""" return self.f_cost < other.f_cost class a : def __init__( self , _snake_case , _snake_case ): """simple docstring""" lowerCAmelCase = Node(start[1] , start[0] , goal[1] , goal[0] , 0 , _snake_case ) lowerCAmelCase = Node(goal[1] , goal[0] , goal[1] , goal[0] , 9_99_99 , _snake_case ) lowerCAmelCase = [self.start] lowerCAmelCase = [] lowerCAmelCase = False def UpperCamelCase__ ( self ): """simple docstring""" while self.open_nodes: # Open Nodes are sorted using __lt__ self.open_nodes.sort() lowerCAmelCase = self.open_nodes.pop(0 ) if current_node.pos == self.target.pos: return self.retrace_path(_snake_case ) self.closed_nodes.append(_snake_case ) lowerCAmelCase = self.get_successors(_snake_case ) for child_node in successors: if child_node in self.closed_nodes: continue if child_node not in self.open_nodes: self.open_nodes.append(_snake_case ) else: # retrieve the best current path lowerCAmelCase = self.open_nodes.pop(self.open_nodes.index(_snake_case ) ) if child_node.g_cost < better_node.g_cost: self.open_nodes.append(_snake_case ) else: self.open_nodes.append(_snake_case ) return [self.start.pos] def UpperCamelCase__ ( self , _snake_case ): """simple docstring""" lowerCAmelCase = [] for action in delta: lowerCAmelCase = parent.pos_x + action[1] lowerCAmelCase = parent.pos_y + action[0] if not (0 <= pos_x <= len(grid[0] ) - 1 and 0 <= pos_y <= len(_snake_case ) - 1): continue if grid[pos_y][pos_x] != 0: continue successors.append( Node( _snake_case , _snake_case , self.target.pos_y , self.target.pos_x , parent.g_cost + 1 , _snake_case , ) ) return successors def UpperCamelCase__ ( self , _snake_case ): """simple docstring""" lowerCAmelCase = node lowerCAmelCase = [] while current_node is not None: path.append((current_node.pos_y, current_node.pos_x) ) lowerCAmelCase = current_node.parent path.reverse() return path class a : def __init__( self , _snake_case , _snake_case ): """simple docstring""" lowerCAmelCase = AStar(_snake_case , _snake_case ) lowerCAmelCase = AStar(_snake_case , _snake_case ) lowerCAmelCase = False def UpperCamelCase__ ( self ): """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() lowerCAmelCase = self.fwd_astar.open_nodes.pop(0 ) lowerCAmelCase = self.bwd_astar.open_nodes.pop(0 ) if current_bwd_node.pos == current_fwd_node.pos: return self.retrace_bidirectional_path( _snake_case , _snake_case ) self.fwd_astar.closed_nodes.append(_snake_case ) self.bwd_astar.closed_nodes.append(_snake_case ) lowerCAmelCase = current_bwd_node lowerCAmelCase = current_fwd_node lowerCAmelCase = { self.fwd_astar: self.fwd_astar.get_successors(_snake_case ), self.bwd_astar: self.bwd_astar.get_successors(_snake_case ), } 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(_snake_case ) else: # retrieve the best current path lowerCAmelCase = astar.open_nodes.pop( astar.open_nodes.index(_snake_case ) ) if child_node.g_cost < better_node.g_cost: astar.open_nodes.append(_snake_case ) else: astar.open_nodes.append(_snake_case ) return [self.fwd_astar.start.pos] def UpperCamelCase__ ( self , _snake_case , _snake_case ): """simple docstring""" lowerCAmelCase = self.fwd_astar.retrace_path(_snake_case ) lowerCAmelCase = self.bwd_astar.retrace_path(_snake_case ) bwd_path.pop() bwd_path.reverse() lowerCAmelCase = fwd_path + bwd_path return path if __name__ == "__main__": # all coordinates are given in format [y,x] __UpperCamelCase : int = (0, 0) __UpperCamelCase : str = (len(grid) - 1, len(grid[0]) - 1) for elem in grid: print(elem) __UpperCamelCase : List[str] = time.time() __UpperCamelCase : Optional[int] = AStar(init, goal) __UpperCamelCase : int = a_star.search() __UpperCamelCase : Any = time.time() - start_time print(f'''AStar execution time = {end_time:f} seconds''') __UpperCamelCase : List[str] = time.time() __UpperCamelCase : Dict = BidirectionalAStar(init, goal) __UpperCamelCase : List[str] = time.time() - bd_start_time print(f'''BidirectionalAStar execution time = {bd_end_time:f} seconds''')
363
"""simple docstring""" from __future__ import annotations import random # Maximum size of the population. Bigger could be faster but is more memory expensive. __UpperCamelCase : str = 200 # Number of elements selected in every generation of evolution. The selection takes # place from best to worst of that generation and must be smaller than N_POPULATION. __UpperCamelCase : Optional[Any] = 50 # Probability that an element of a generation can mutate, changing one of its genes. # This will guarantee that all genes will be used during evolution. __UpperCamelCase : Dict = 0.4 # Just a seed to improve randomness required by the algorithm. random.seed(random.randint(0, 1000)) def _SCREAMING_SNAKE_CASE (_UpperCAmelCase : str , _UpperCAmelCase : str ): lowerCAmelCase = len([g for position, g in enumerate(_UpperCAmelCase ) if g == main_target[position]] ) return (item, float(_UpperCAmelCase )) def _SCREAMING_SNAKE_CASE (_UpperCAmelCase : str , _UpperCAmelCase : str ): lowerCAmelCase = random.randint(0 , len(_UpperCAmelCase ) - 1 ) lowerCAmelCase = parent_a[:random_slice] + parent_a[random_slice:] lowerCAmelCase = parent_a[:random_slice] + parent_a[random_slice:] return (child_a, child_a) def _SCREAMING_SNAKE_CASE (_UpperCAmelCase : str , _UpperCAmelCase : list[str] ): lowerCAmelCase = list(_UpperCAmelCase ) if random.uniform(0 , 1 ) < MUTATION_PROBABILITY: lowerCAmelCase = random.choice(_UpperCAmelCase ) return "".join(_UpperCAmelCase ) def _SCREAMING_SNAKE_CASE (_UpperCAmelCase : tuple[str, float] , _UpperCAmelCase : list[tuple[str, float]] , _UpperCAmelCase : list[str] , ): lowerCAmelCase = [] # Generate more children proportionally to the fitness score. lowerCAmelCase = int(parent_a[1] * 100 ) + 1 lowerCAmelCase = 10 if child_n >= 10 else child_n for _ in range(_UpperCAmelCase ): lowerCAmelCase = population_score[random.randint(0 , _UpperCAmelCase )][0] lowerCAmelCase ,lowerCAmelCase = crossover(parent_a[0] , _UpperCAmelCase ) # Append new string to the population list. pop.append(mutate(_UpperCAmelCase , _UpperCAmelCase ) ) pop.append(mutate(_UpperCAmelCase , _UpperCAmelCase ) ) return pop def _SCREAMING_SNAKE_CASE (_UpperCAmelCase : str , _UpperCAmelCase : list[str] , _UpperCAmelCase : bool = True ): # Verify if N_POPULATION is bigger than N_SELECTED if N_POPULATION < N_SELECTED: lowerCAmelCase = F'{N_POPULATION} must be bigger than {N_SELECTED}' raise ValueError(_UpperCAmelCase ) # Verify that the target contains no genes besides the ones inside genes variable. lowerCAmelCase = sorted({c for c in target if c not in genes} ) if not_in_genes_list: lowerCAmelCase = F'{not_in_genes_list} is not in genes list, evolution cannot converge' raise ValueError(_UpperCAmelCase ) # Generate random starting population. lowerCAmelCase = [] for _ in range(_UpperCAmelCase ): population.append(''.join([random.choice(_UpperCAmelCase ) for i in range(len(_UpperCAmelCase ) )] ) ) # Just some logs to know what the algorithms is doing. lowerCAmelCase ,lowerCAmelCase = 0, 0 # This loop will end when we find a perfect match for our target. while True: generation += 1 total_population += len(_UpperCAmelCase ) # Random population created. Now it's time to evaluate. # Adding a bit of concurrency can make everything faster, # # import concurrent.futures # population_score: list[tuple[str, float]] = [] # with concurrent.futures.ThreadPoolExecutor( # max_workers=NUM_WORKERS) as executor: # futures = {executor.submit(evaluate, item) for item in population} # concurrent.futures.wait(futures) # population_score = [item.result() for item in futures] # # but with a simple algorithm like this, it will probably be slower. # We just need to call evaluate for every item inside the population. lowerCAmelCase = [evaluate(_UpperCAmelCase , _UpperCAmelCase ) for item in population] # Check if there is a matching evolution. lowerCAmelCase = sorted(_UpperCAmelCase , key=lambda _UpperCAmelCase : x[1] , reverse=_UpperCAmelCase ) if population_score[0][0] == target: return (generation, total_population, population_score[0][0]) # Print the best result every 10 generation. # Just to know that the algorithm is working. if debug and generation % 10 == 0: print( F'\nGeneration: {generation}' F'\nTotal Population:{total_population}' F'\nBest score: {population_score[0][1]}' F'\nBest string: {population_score[0][0]}' ) # Flush the old population, keeping some of the best evolutions. # Keeping this avoid regression of evolution. lowerCAmelCase = population[: int(N_POPULATION / 3 )] population.clear() population.extend(_UpperCAmelCase ) # Normalize population score to be between 0 and 1. lowerCAmelCase = [ (item, score / len(_UpperCAmelCase )) for item, score in population_score ] # This is selection for i in range(_UpperCAmelCase ): population.extend(select(population_score[int(_UpperCAmelCase )] , _UpperCAmelCase , _UpperCAmelCase ) ) # Check if the population has already reached the maximum value and if so, # break the cycle. If this check is disabled, the algorithm will take # forever to compute large strings, but will also calculate small strings in # a far fewer generations. if len(_UpperCAmelCase ) > N_POPULATION: break if __name__ == "__main__": __UpperCamelCase : Tuple = ( '''This is a genetic algorithm to evaluate, combine, evolve, and mutate a string!''' ) __UpperCamelCase : str = list( ''' ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklm''' '''nopqrstuvwxyz.,;!?+-*#@^\'èéòà€ù=)(&%$£/\\''' ) __UpperCamelCase ,__UpperCamelCase ,__UpperCamelCase : Dict = basic(target_str, genes_list) print( f'''\nGeneration: {generation}\nTotal Population: {population}\nTarget: {target}''' )
309
0
def A (__A : int , __A : int ) -> bool: """simple docstring""" return numa ^ numa < 0 if __name__ == "__main__": import doctest doctest.testmod()
51
from math import loga def lowerCamelCase__ ( snake_case_ : int ) -> int: if a < 0: raise ValueError('''Input value must be a positive integer''' ) elif isinstance(snake_case_ , snake_case_ ): 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()
24
0
"""simple docstring""" import torch from diffusers import KDPMaDiscreteScheduler from diffusers.utils import torch_device from .test_schedulers import SchedulerCommonTest class UpperCamelCase_ (__A ): __magic_name__ = (KDPMaDiscreteScheduler,) __magic_name__ = 10 def _SCREAMING_SNAKE_CASE ( self : int , **lowerCAmelCase_ : int ) -> str: UpperCAmelCase_ : int = { "num_train_timesteps": 1_100, "beta_start": 0.0_0_0_1, "beta_end": 0.0_2, "beta_schedule": "linear", } config.update(**lowerCAmelCase_ ) return config def _SCREAMING_SNAKE_CASE ( self : List[Any] ) -> List[Any]: for timesteps in [10, 50, 100, 1_000]: self.check_over_configs(num_train_timesteps=lowerCAmelCase_ ) def _SCREAMING_SNAKE_CASE ( self : Union[str, Any] ) -> Union[str, Any]: for beta_start, beta_end in zip([0.0_0_0_0_1, 0.0_0_0_1, 0.0_0_1] , [0.0_0_0_2, 0.0_0_2, 0.0_2] ): self.check_over_configs(beta_start=lowerCAmelCase_ , beta_end=lowerCAmelCase_ ) def _SCREAMING_SNAKE_CASE ( self : str ) -> str: for schedule in ["linear", "scaled_linear"]: self.check_over_configs(beta_schedule=lowerCAmelCase_ ) def _SCREAMING_SNAKE_CASE ( self : Any ) -> List[Any]: for prediction_type in ["epsilon", "v_prediction"]: self.check_over_configs(prediction_type=lowerCAmelCase_ ) def _SCREAMING_SNAKE_CASE ( self : Tuple ) -> Tuple: UpperCAmelCase_ : Optional[Any] = self.scheduler_classes[0] UpperCAmelCase_ : str = self.get_scheduler_config(prediction_type="v_prediction" ) UpperCAmelCase_ : Tuple = scheduler_class(**lowerCAmelCase_ ) scheduler.set_timesteps(self.num_inference_steps ) UpperCAmelCase_ : Union[str, Any] = self.dummy_model() UpperCAmelCase_ : List[Any] = self.dummy_sample_deter * scheduler.init_noise_sigma UpperCAmelCase_ : Optional[int] = sample.to(lowerCAmelCase_ ) for i, t in enumerate(scheduler.timesteps ): UpperCAmelCase_ : Any = scheduler.scale_model_input(lowerCAmelCase_ , lowerCAmelCase_ ) UpperCAmelCase_ : List[Any] = model(lowerCAmelCase_ , lowerCAmelCase_ ) UpperCAmelCase_ : Any = scheduler.step(lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ ) UpperCAmelCase_ : str = output.prev_sample UpperCAmelCase_ : Tuple = torch.sum(torch.abs(lowerCAmelCase_ ) ) UpperCAmelCase_ : Tuple = torch.mean(torch.abs(lowerCAmelCase_ ) ) if torch_device in ["cpu", "mps"]: assert abs(result_sum.item() - 4.6_934e-07 ) < 1e-2 assert abs(result_mean.item() - 6.1_112e-10 ) < 1e-3 else: # CUDA assert abs(result_sum.item() - 4.693_428_650_170_972e-07 ) < 1e-2 assert abs(result_mean.item() - 0.0_0_0_2 ) < 1e-3 def _SCREAMING_SNAKE_CASE ( self : Any ) -> Optional[int]: if torch_device == "mps": return UpperCAmelCase_ : List[Any] = self.scheduler_classes[0] UpperCAmelCase_ : Dict = self.get_scheduler_config() UpperCAmelCase_ : int = scheduler_class(**lowerCAmelCase_ ) scheduler.set_timesteps(self.num_inference_steps ) UpperCAmelCase_ : Union[str, Any] = self.dummy_model() UpperCAmelCase_ : Optional[Any] = self.dummy_sample_deter * scheduler.init_noise_sigma UpperCAmelCase_ : Optional[int] = sample.to(lowerCAmelCase_ ) for i, t in enumerate(scheduler.timesteps ): UpperCAmelCase_ : int = scheduler.scale_model_input(lowerCAmelCase_ , lowerCAmelCase_ ) UpperCAmelCase_ : Any = model(lowerCAmelCase_ , lowerCAmelCase_ ) UpperCAmelCase_ : int = scheduler.step(lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ ) UpperCAmelCase_ : Optional[int] = output.prev_sample UpperCAmelCase_ : str = torch.sum(torch.abs(lowerCAmelCase_ ) ) UpperCAmelCase_ : Optional[Any] = torch.mean(torch.abs(lowerCAmelCase_ ) ) if torch_device in ["cpu", "mps"]: assert abs(result_sum.item() - 2_0.4_1_2_5 ) < 1e-2 assert abs(result_mean.item() - 0.0_2_6_6 ) < 1e-3 else: # CUDA assert abs(result_sum.item() - 2_0.4_1_2_5 ) < 1e-2 assert abs(result_mean.item() - 0.0_2_6_6 ) < 1e-3 def _SCREAMING_SNAKE_CASE ( self : List[Any] ) -> int: if torch_device == "mps": return UpperCAmelCase_ : Dict = self.scheduler_classes[0] UpperCAmelCase_ : Tuple = self.get_scheduler_config() UpperCAmelCase_ : Optional[int] = scheduler_class(**lowerCAmelCase_ ) scheduler.set_timesteps(self.num_inference_steps , device=lowerCAmelCase_ ) UpperCAmelCase_ : Optional[Any] = self.dummy_model() UpperCAmelCase_ : str = self.dummy_sample_deter.to(lowerCAmelCase_ ) * scheduler.init_noise_sigma for t in scheduler.timesteps: UpperCAmelCase_ : Any = scheduler.scale_model_input(lowerCAmelCase_ , lowerCAmelCase_ ) UpperCAmelCase_ : int = model(lowerCAmelCase_ , lowerCAmelCase_ ) UpperCAmelCase_ : str = scheduler.step(lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ ) UpperCAmelCase_ : List[str] = output.prev_sample UpperCAmelCase_ : Any = torch.sum(torch.abs(lowerCAmelCase_ ) ) UpperCAmelCase_ : List[Any] = torch.mean(torch.abs(lowerCAmelCase_ ) ) if str(lowerCAmelCase_ ).startswith("cpu" ): # The following sum varies between 148 and 156 on mps. Why? assert abs(result_sum.item() - 2_0.4_1_2_5 ) < 1e-2 assert abs(result_mean.item() - 0.0_2_6_6 ) < 1e-3 else: # CUDA assert abs(result_sum.item() - 2_0.4_1_2_5 ) < 1e-2 assert abs(result_mean.item() - 0.0_2_6_6 ) < 1e-3
253
"""simple docstring""" from collections import OrderedDict from typing import Mapping from packaging import version from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging from ..auto import CONFIG_MAPPING lowerCamelCase_ = logging.get_logger(__name__) lowerCamelCase_ = { '''microsoft/table-transformer-detection''': ( '''https://huggingface.co/microsoft/table-transformer-detection/resolve/main/config.json''' ), } class UpperCamelCase_ (__A ): __magic_name__ = '''table-transformer''' __magic_name__ = ['''past_key_values'''] __magic_name__ = { '''hidden_size''': '''d_model''', '''num_attention_heads''': '''encoder_attention_heads''', } def __init__( self : List[Any] , lowerCAmelCase_ : List[Any]=True , lowerCAmelCase_ : Union[str, Any]=None , lowerCAmelCase_ : Optional[Any]=3 , lowerCAmelCase_ : Optional[Any]=100 , lowerCAmelCase_ : Optional[int]=6 , lowerCAmelCase_ : List[Any]=2_048 , lowerCAmelCase_ : Tuple=8 , lowerCAmelCase_ : Dict=6 , lowerCAmelCase_ : List[Any]=2_048 , lowerCAmelCase_ : Optional[int]=8 , lowerCAmelCase_ : Tuple=0.0 , lowerCAmelCase_ : str=0.0 , lowerCAmelCase_ : str=True , lowerCAmelCase_ : Optional[int]="relu" , lowerCAmelCase_ : List[Any]=256 , lowerCAmelCase_ : Optional[Any]=0.1 , lowerCAmelCase_ : Optional[int]=0.0 , lowerCAmelCase_ : Union[str, Any]=0.0 , lowerCAmelCase_ : Dict=0.0_2 , lowerCAmelCase_ : Any=1.0 , lowerCAmelCase_ : Any=False , lowerCAmelCase_ : Dict="sine" , lowerCAmelCase_ : Optional[Any]="resnet50" , lowerCAmelCase_ : int=True , lowerCAmelCase_ : Union[str, Any]=False , lowerCAmelCase_ : int=1 , lowerCAmelCase_ : int=5 , lowerCAmelCase_ : Union[str, Any]=2 , lowerCAmelCase_ : Any=1 , lowerCAmelCase_ : List[str]=1 , lowerCAmelCase_ : List[Any]=5 , lowerCAmelCase_ : Optional[Any]=2 , lowerCAmelCase_ : Optional[Any]=0.1 , **lowerCAmelCase_ : Dict , ) -> Union[str, Any]: if backbone_config is not None and use_timm_backbone: raise ValueError("You can't specify both `backbone_config` and `use_timm_backbone`." ) if not use_timm_backbone: if backbone_config is None: logger.info("`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone." ) UpperCAmelCase_ : Union[str, Any] = CONFIG_MAPPING["resnet"](out_features=["stage4"] ) elif isinstance(lowerCAmelCase_ , lowerCAmelCase_ ): UpperCAmelCase_ : Dict = backbone_config.get("model_type" ) UpperCAmelCase_ : str = CONFIG_MAPPING[backbone_model_type] UpperCAmelCase_ : Any = config_class.from_dict(lowerCAmelCase_ ) # set timm attributes to None UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : str = None, None, None UpperCAmelCase_ : int = use_timm_backbone UpperCAmelCase_ : int = backbone_config UpperCAmelCase_ : Dict = num_channels UpperCAmelCase_ : Optional[Any] = num_queries UpperCAmelCase_ : List[str] = d_model UpperCAmelCase_ : Union[str, Any] = encoder_ffn_dim UpperCAmelCase_ : Optional[Any] = encoder_layers UpperCAmelCase_ : List[str] = encoder_attention_heads UpperCAmelCase_ : int = decoder_ffn_dim UpperCAmelCase_ : int = decoder_layers UpperCAmelCase_ : Optional[int] = decoder_attention_heads UpperCAmelCase_ : List[str] = dropout UpperCAmelCase_ : Dict = attention_dropout UpperCAmelCase_ : Union[str, Any] = activation_dropout UpperCAmelCase_ : Optional[int] = activation_function UpperCAmelCase_ : int = init_std UpperCAmelCase_ : Any = init_xavier_std UpperCAmelCase_ : Union[str, Any] = encoder_layerdrop UpperCAmelCase_ : Dict = decoder_layerdrop UpperCAmelCase_ : Union[str, Any] = encoder_layers UpperCAmelCase_ : Any = auxiliary_loss UpperCAmelCase_ : List[str] = position_embedding_type UpperCAmelCase_ : Dict = backbone UpperCAmelCase_ : Optional[int] = use_pretrained_backbone UpperCAmelCase_ : Tuple = dilation # Hungarian matcher UpperCAmelCase_ : Optional[Any] = class_cost UpperCAmelCase_ : List[Any] = bbox_cost UpperCAmelCase_ : Optional[int] = giou_cost # Loss coefficients UpperCAmelCase_ : Optional[int] = mask_loss_coefficient UpperCAmelCase_ : List[str] = dice_loss_coefficient UpperCAmelCase_ : Union[str, Any] = bbox_loss_coefficient UpperCAmelCase_ : Union[str, Any] = giou_loss_coefficient UpperCAmelCase_ : Dict = eos_coefficient super().__init__(is_encoder_decoder=lowerCAmelCase_ , **lowerCAmelCase_ ) @property def _SCREAMING_SNAKE_CASE ( self : Union[str, Any] ) -> int: return self.encoder_attention_heads @property def _SCREAMING_SNAKE_CASE ( self : List[Any] ) -> int: return self.d_model class UpperCamelCase_ (__A ): __magic_name__ = version.parse('''1.11''' ) @property def _SCREAMING_SNAKE_CASE ( self : List[str] ) -> Mapping[str, Mapping[int, str]]: return OrderedDict( [ ("pixel_values", {0: "batch", 1: "num_channels", 2: "height", 3: "width"}), ("pixel_mask", {0: "batch"}), ] ) @property def _SCREAMING_SNAKE_CASE ( self : Optional[int] ) -> float: return 1e-5 @property def _SCREAMING_SNAKE_CASE ( self : Optional[int] ) -> int: return 12
253
1
'''simple docstring''' import unittest from transformers import RoFormerTokenizer, RoFormerTokenizerFast from transformers.testing_utils import require_rjieba, require_tokenizers from ...test_tokenization_common import TokenizerTesterMixin @require_rjieba @require_tokenizers class UpperCamelCase__ ( __lowerCamelCase , unittest.TestCase): UpperCAmelCase__ : Union[str, Any] = RoFormerTokenizer UpperCAmelCase__ : Dict = RoFormerTokenizerFast UpperCAmelCase__ : Union[str, Any] = True UpperCAmelCase__ : Tuple = True def lowercase_ ( self :str ) -> Union[str, Any]: '''simple docstring''' super().setUp() def lowercase_ ( self :Optional[int] , **_A :List[str] ) -> Tuple: '''simple docstring''' return self.tokenizer_class.from_pretrained('junnyu/roformer_chinese_base' , **UpperCamelCase_ ) def lowercase_ ( self :Dict , **_A :str ) -> int: '''simple docstring''' return self.rust_tokenizer_class.from_pretrained('junnyu/roformer_chinese_base' , **UpperCamelCase_ ) def lowercase_ ( self :List[Any] ) -> List[Any]: '''simple docstring''' __A = '永和服装饰品有限公司,今天天气非常好' __A = '永和 服装 饰品 有限公司 , 今 天 天 气 非常 好' return input_text, output_text def lowercase_ ( self :Optional[Any] ) -> str: '''simple docstring''' __A = self.get_tokenizer() __A , __A = self.get_chinese_input_output_texts() __A = tokenizer.tokenize(UpperCamelCase_ ) self.assertListEqual(UpperCamelCase_ , output_text.split() ) __A = tokens + [tokenizer.unk_token] __A = [22_943, 21_332, 34_431, 45_904, 117, 306, 1_231, 1_231, 2_653, 33_994, 1_266, 100] self.assertListEqual(tokenizer.convert_tokens_to_ids(UpperCamelCase_ ) , UpperCamelCase_ ) def lowercase_ ( self :Optional[Any] ) -> str: '''simple docstring''' __A = self.get_rust_tokenizer() __A , __A = self.get_chinese_input_output_texts() __A = tokenizer.tokenize(UpperCamelCase_ ) self.assertListEqual(UpperCamelCase_ , output_text.split() ) __A = tokens + [tokenizer.unk_token] __A = [22_943, 21_332, 34_431, 45_904, 117, 306, 1_231, 1_231, 2_653, 33_994, 1_266, 100] self.assertListEqual(tokenizer.convert_tokens_to_ids(UpperCamelCase_ ) , UpperCamelCase_ ) def lowercase_ ( self :Any ) -> Optional[Any]: '''simple docstring''' pass def lowercase_ ( self :Union[str, Any] ) -> Optional[int]: '''simple docstring''' pass def lowercase_ ( self :Any ) -> Optional[int]: '''simple docstring''' pass
161
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__)
12
0
import argparse import gc import json import os import torch from datasets import load_dataset from torch.optim import AdamW from torch.utils.data import DataLoader from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed from accelerate import Accelerator, DistributedType from accelerate.utils.deepspeed import DummyOptim, DummyScheduler __UpperCAmelCase = 16 __UpperCAmelCase = 32 def UpperCamelCase ( snake_case__ : Optional[int] ) -> Optional[Any]: return int(x / 2**20 ) class lowerCAmelCase_ : def __enter__( self ) -> List[str]: gc.collect() torch.cuda.empty_cache() torch.cuda.reset_max_memory_allocated() # reset the peak gauge to zero UpperCamelCase : List[Any] = torch.cuda.memory_allocated() return self def __exit__( self, *SCREAMING_SNAKE_CASE_ ) -> Union[str, Any]: gc.collect() torch.cuda.empty_cache() UpperCamelCase : List[str] = torch.cuda.memory_allocated() UpperCamelCase : Dict = torch.cuda.max_memory_allocated() UpperCamelCase : str = bamb(self.end - self.begin ) UpperCamelCase : List[str] = bamb(self.peak - self.begin ) # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}") def UpperCamelCase ( snake_case__ : Accelerator , snake_case__ : int = 16 , snake_case__ : str = "bert-base-cased" , snake_case__ : int = 320 , snake_case__ : int = 160 , ) -> List[str]: UpperCamelCase : Optional[int] = AutoTokenizer.from_pretrained(snake_case__ ) UpperCamelCase : Union[str, Any] = load_dataset( 'glue' , 'mrpc' , split={'train': F"""train[:{n_train}]""", 'validation': F"""validation[:{n_val}]"""} ) def tokenize_function(snake_case__ : Tuple ): # max_length=None => use the model max length (it's actually the default) UpperCamelCase : List[str] = tokenizer(examples['sentence1'] , examples['sentence2'] , truncation=snake_case__ , max_length=snake_case__ ) return outputs # Apply the method we just defined to all the examples in all the splits of the dataset UpperCamelCase : Dict = datasets.map( snake_case__ , batched=snake_case__ , remove_columns=['idx', 'sentence1', 'sentence2'] , load_from_cache_file=snake_case__ ) # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the # transformers library UpperCamelCase : List[str] = tokenized_datasets.rename_column('label' , 'labels' ) def collate_fn(snake_case__ : str ): # On TPU it's best to pad everything to the same length or training will be very slow. if accelerator.distributed_type == DistributedType.TPU: return tokenizer.pad(snake_case__ , padding='max_length' , max_length=128 , return_tensors='pt' ) return tokenizer.pad(snake_case__ , padding='longest' , return_tensors='pt' ) # Instantiate dataloaders. UpperCamelCase : List[Any] = DataLoader( tokenized_datasets['train'] , shuffle=snake_case__ , collate_fn=snake_case__ , batch_size=snake_case__ ) UpperCamelCase : List[str] = DataLoader( tokenized_datasets['validation'] , shuffle=snake_case__ , collate_fn=snake_case__ , batch_size=snake_case__ ) return train_dataloader, eval_dataloader def UpperCamelCase ( snake_case__ : Any , snake_case__ : int ) -> Optional[int]: # Initialize accelerator UpperCamelCase : Optional[int] = Accelerator() # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs UpperCamelCase : List[Any] = config['lr'] UpperCamelCase : List[str] = int(config['num_epochs'] ) UpperCamelCase : Tuple = int(config['seed'] ) UpperCamelCase : Tuple = int(config['batch_size'] ) UpperCamelCase : Union[str, Any] = args.model_name_or_path set_seed(snake_case__ ) UpperCamelCase : str = get_dataloaders(snake_case__ , snake_case__ , snake_case__ , args.n_train , args.n_val ) # Instantiate the model (we build the model here so that the seed also control new weights initialization) UpperCamelCase : str = AutoModelForSequenceClassification.from_pretrained(snake_case__ , return_dict=snake_case__ ) # Instantiate optimizer UpperCamelCase : Any = ( AdamW if accelerator.state.deepspeed_plugin is None or 'optimizer' not in accelerator.state.deepspeed_plugin.deepspeed_config else DummyOptim ) UpperCamelCase : str = optimizer_cls(params=model.parameters() , lr=snake_case__ ) if accelerator.state.deepspeed_plugin is not None: UpperCamelCase : Tuple = accelerator.state.deepspeed_plugin.deepspeed_config[ 'gradient_accumulation_steps' ] else: UpperCamelCase : Any = 1 UpperCamelCase : Dict = (len(snake_case__ ) * num_epochs) // gradient_accumulation_steps # Instantiate scheduler if ( accelerator.state.deepspeed_plugin is None or "scheduler" not in accelerator.state.deepspeed_plugin.deepspeed_config ): UpperCamelCase : Dict = get_linear_schedule_with_warmup( optimizer=snake_case__ , num_warmup_steps=0 , num_training_steps=snake_case__ , ) else: UpperCamelCase : List[str] = DummyScheduler(snake_case__ , total_num_steps=snake_case__ , warmup_num_steps=0 ) # Prepare everything # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the # prepare method. UpperCamelCase : int = accelerator.prepare( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ ) # We need to keep track of how many total steps we have iterated over UpperCamelCase : Optional[int] = 0 # We also need to keep track of the stating epoch so files are named properly UpperCamelCase : Union[str, Any] = 0 # Now we train the model UpperCamelCase : int = {} for epoch in range(snake_case__ , snake_case__ ): with TorchTracemalloc() as tracemalloc: model.train() for step, batch in enumerate(snake_case__ ): UpperCamelCase : Dict = model(**snake_case__ ) UpperCamelCase : Dict = outputs.loss UpperCamelCase : Any = loss / gradient_accumulation_steps accelerator.backward(snake_case__ ) if step % gradient_accumulation_steps == 0: optimizer.step() lr_scheduler.step() optimizer.zero_grad() overall_step += 1 # Printing the GPU memory usage details such as allocated memory, peak memory, and total memory usage accelerator.print('Memory before entering the train : {}'.format(bamb(tracemalloc.begin ) ) ) accelerator.print('Memory consumed at the end of the train (end-begin): {}'.format(tracemalloc.used ) ) accelerator.print('Peak Memory consumed during the train (max-begin): {}'.format(tracemalloc.peaked ) ) accelerator.print( 'Total Peak Memory consumed during the train (max): {}'.format( tracemalloc.peaked + bamb(tracemalloc.begin ) ) ) UpperCamelCase : Optional[int] = tracemalloc.peaked + bamb(tracemalloc.begin ) if args.peak_memory_upper_bound is not None: assert ( train_total_peak_memory[F"""epoch-{epoch}"""] <= args.peak_memory_upper_bound ), "Peak memory usage exceeded the upper bound" accelerator.wait_for_everyone() if accelerator.is_main_process: with open(os.path.join(args.output_dir , 'peak_memory_utilization.json' ) , 'w' ) as f: json.dump(snake_case__ , snake_case__ ) def UpperCamelCase ( ) -> int: UpperCamelCase : Optional[int] = argparse.ArgumentParser(description='Simple example of training script tracking peak GPU memory usage.' ) parser.add_argument( '--model_name_or_path' , type=snake_case__ , default='bert-base-cased' , help='Path to pretrained model or model identifier from huggingface.co/models.' , required=snake_case__ , ) parser.add_argument( '--output_dir' , type=snake_case__ , default='.' , help='Optional save directory where all checkpoint folders will be stored. Default is the current working directory.' , ) parser.add_argument( '--peak_memory_upper_bound' , type=snake_case__ , default=snake_case__ , help='The upper bound of peak memory usage in MB. If set, the training will throw an error if the peak memory usage exceeds this value.' , ) parser.add_argument( '--n_train' , type=snake_case__ , default=320 , help='Number of training examples to use.' , ) parser.add_argument( '--n_val' , type=snake_case__ , default=160 , help='Number of validation examples to use.' , ) parser.add_argument( '--num_epochs' , type=snake_case__ , default=1 , help='Number of train epochs.' , ) UpperCamelCase : int = parser.parse_args() UpperCamelCase : Optional[Any] = {'lr': 2E-5, 'num_epochs': args.num_epochs, 'seed': 42, 'batch_size': 16} training_function(snake_case__ , snake_case__ ) if __name__ == "__main__": main()
358
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, prepare_image_inputs if is_torch_available(): import torch if is_vision_available(): from PIL import Image from transformers import ViTImageProcessor class lowerCAmelCase_ ( unittest.TestCase ): def __init__( self, SCREAMING_SNAKE_CASE_, SCREAMING_SNAKE_CASE_=13, SCREAMING_SNAKE_CASE_=3, SCREAMING_SNAKE_CASE_=224, SCREAMING_SNAKE_CASE_=30, SCREAMING_SNAKE_CASE_=400, SCREAMING_SNAKE_CASE_=True, SCREAMING_SNAKE_CASE_=None, SCREAMING_SNAKE_CASE_=True, SCREAMING_SNAKE_CASE_=[0.5, 0.5, 0.5], SCREAMING_SNAKE_CASE_=[0.5, 0.5, 0.5], ) -> List[str]: UpperCamelCase : Optional[int] = size if size is not None else {'height': 18, 'width': 18} UpperCamelCase : List[Any] = parent UpperCamelCase : List[Any] = batch_size UpperCamelCase : int = num_channels UpperCamelCase : int = image_size UpperCamelCase : List[Any] = min_resolution UpperCamelCase : int = max_resolution UpperCamelCase : Any = do_resize UpperCamelCase : Optional[int] = size UpperCamelCase : List[str] = do_normalize UpperCamelCase : Optional[Any] = image_mean UpperCamelCase : Tuple = image_std def snake_case_ ( self ) -> List[Any]: return { "image_mean": self.image_mean, "image_std": self.image_std, "do_normalize": self.do_normalize, "do_resize": self.do_resize, "size": self.size, } @require_torch @require_vision class lowerCAmelCase_ ( a__ , unittest.TestCase ): UpperCAmelCase__ : Optional[Any] = ViTImageProcessor if is_vision_available() else None def snake_case_ ( self ) -> Any: UpperCamelCase : Dict = EfficientFormerImageProcessorTester(self ) @property def snake_case_ ( self ) -> List[Any]: return self.image_proc_tester.prepare_image_processor_dict() def snake_case_ ( self ) -> Optional[int]: UpperCamelCase : Optional[int] = self.image_processing_class(**self.image_processor_dict ) self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_, 'image_mean' ) ) self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_, 'image_std' ) ) self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_, 'do_normalize' ) ) self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_, 'do_resize' ) ) self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_, 'size' ) ) def snake_case_ ( self ) -> Any: pass def snake_case_ ( self ) -> int: # Initialize image_processor UpperCamelCase : Union[str, Any] = self.image_processing_class(**self.image_processor_dict ) # create random PIL images UpperCamelCase : List[str] = prepare_image_inputs(self.image_proc_tester, equal_resolution=SCREAMING_SNAKE_CASE_ ) for image in image_inputs: self.assertIsInstance(SCREAMING_SNAKE_CASE_, Image.Image ) # Test not batched input UpperCamelCase : str = image_processor(image_inputs[0], return_tensors='pt' ).pixel_values self.assertEqual( encoded_images.shape, ( 1, self.image_proc_tester.num_channels, self.image_proc_tester.size['height'], self.image_proc_tester.size['width'], ), ) # Test batched UpperCamelCase : Optional[Any] = image_processor(SCREAMING_SNAKE_CASE_, return_tensors='pt' ).pixel_values self.assertEqual( encoded_images.shape, ( self.image_proc_tester.batch_size, self.image_proc_tester.num_channels, self.image_proc_tester.size['height'], self.image_proc_tester.size['width'], ), ) def snake_case_ ( self ) -> str: # Initialize image_processor UpperCamelCase : List[str] = self.image_processing_class(**self.image_processor_dict ) # create random numpy tensors UpperCamelCase : Union[str, Any] = prepare_image_inputs(self.image_proc_tester, equal_resolution=SCREAMING_SNAKE_CASE_, numpify=SCREAMING_SNAKE_CASE_ ) for image in image_inputs: self.assertIsInstance(SCREAMING_SNAKE_CASE_, np.ndarray ) # Test not batched input UpperCamelCase : Dict = image_processor(image_inputs[0], return_tensors='pt' ).pixel_values self.assertEqual( encoded_images.shape, ( 1, self.image_proc_tester.num_channels, self.image_proc_tester.size['height'], self.image_proc_tester.size['width'], ), ) # Test batched UpperCamelCase : Dict = image_processor(SCREAMING_SNAKE_CASE_, return_tensors='pt' ).pixel_values self.assertEqual( encoded_images.shape, ( self.image_proc_tester.batch_size, self.image_proc_tester.num_channels, self.image_proc_tester.size['height'], self.image_proc_tester.size['width'], ), ) def snake_case_ ( self ) -> Tuple: # Initialize image_processor UpperCamelCase : Any = self.image_processing_class(**self.image_processor_dict ) # create random PyTorch tensors UpperCamelCase : int = prepare_image_inputs(self.image_proc_tester, equal_resolution=SCREAMING_SNAKE_CASE_, torchify=SCREAMING_SNAKE_CASE_ ) for image in image_inputs: self.assertIsInstance(SCREAMING_SNAKE_CASE_, torch.Tensor ) # Test not batched input UpperCamelCase : Optional[int] = image_processor(image_inputs[0], return_tensors='pt' ).pixel_values self.assertEqual( encoded_images.shape, ( 1, self.image_proc_tester.num_channels, self.image_proc_tester.size['height'], self.image_proc_tester.size['width'], ), ) # Test batched UpperCamelCase : int = image_processor(SCREAMING_SNAKE_CASE_, return_tensors='pt' ).pixel_values self.assertEqual( encoded_images.shape, ( self.image_proc_tester.batch_size, self.image_proc_tester.num_channels, self.image_proc_tester.size['height'], self.image_proc_tester.size['width'], ), )
103
0
import math import time from transformers import Trainer, is_torch_tpu_available from transformers.trainer_utils import PredictionOutput, speed_metrics if is_torch_tpu_available(check_device=False): import torch_xla.core.xla_model as xm import torch_xla.debug.metrics as met class __lowerCAmelCase ( lowerCamelCase__ ): def __init__( self , *_snake_case , _snake_case=None , _snake_case=None , **_snake_case ): """simple docstring""" super().__init__(*SCREAMING_SNAKE_CASE_ , **SCREAMING_SNAKE_CASE_ ) _lowerCAmelCase = eval_examples _lowerCAmelCase = post_process_function def snake_case ( self , _snake_case=None , _snake_case=None , _snake_case=None , _snake_case = "eval" ): """simple docstring""" _lowerCAmelCase = self.eval_dataset if eval_dataset is None else eval_dataset _lowerCAmelCase = self.get_eval_dataloader(SCREAMING_SNAKE_CASE_ ) _lowerCAmelCase = self.eval_examples if eval_examples is None else eval_examples # Temporarily disable metric computation, we will do it in the loop here. _lowerCAmelCase = self.compute_metrics _lowerCAmelCase = None _lowerCAmelCase = self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop _lowerCAmelCase = time.time() try: _lowerCAmelCase = eval_loop( SCREAMING_SNAKE_CASE_ , description="""Evaluation""" , prediction_loss_only=True if compute_metrics is None else None , ignore_keys=SCREAMING_SNAKE_CASE_ , metric_key_prefix=SCREAMING_SNAKE_CASE_ , ) finally: _lowerCAmelCase = compute_metrics _lowerCAmelCase = self.args.eval_batch_size * self.args.world_size if F'{metric_key_prefix}_jit_compilation_time' in output.metrics: start_time += output.metrics[F'{metric_key_prefix}_jit_compilation_time'] output.metrics.update( speed_metrics( SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , num_samples=output.num_samples , num_steps=math.ceil(output.num_samples / total_batch_size ) , ) ) if self.post_process_function is not None and self.compute_metrics is not None and self.args.should_save: # Only the main node write the results by default _lowerCAmelCase = self.post_process_function(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , output.predictions ) _lowerCAmelCase = self.compute_metrics(SCREAMING_SNAKE_CASE_ ) # Prefix all keys with metric_key_prefix + '_' for key in list(metrics.keys() ): if not key.startswith(F'{metric_key_prefix}_' ): _lowerCAmelCase = metrics.pop(SCREAMING_SNAKE_CASE_ ) metrics.update(output.metrics ) else: _lowerCAmelCase = output.metrics if self.args.should_log: # Only the main node log the results by default self.log(SCREAMING_SNAKE_CASE_ ) if self.args.tpu_metrics_debug or self.args.debug: # tpu-comment: Logging debug metrics for PyTorch/XLA (compile, execute times, ops, etc.) xm.master_print(met.metrics_report() ) _lowerCAmelCase = self.callback_handler.on_evaluate(self.args , self.state , self.control , SCREAMING_SNAKE_CASE_ ) return metrics def snake_case ( self , _snake_case , _snake_case , _snake_case=None , _snake_case = "test" ): """simple docstring""" _lowerCAmelCase = self.get_test_dataloader(SCREAMING_SNAKE_CASE_ ) # Temporarily disable metric computation, we will do it in the loop here. _lowerCAmelCase = self.compute_metrics _lowerCAmelCase = None _lowerCAmelCase = self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop _lowerCAmelCase = time.time() try: _lowerCAmelCase = eval_loop( SCREAMING_SNAKE_CASE_ , description="""Prediction""" , prediction_loss_only=True if compute_metrics is None else None , ignore_keys=SCREAMING_SNAKE_CASE_ , metric_key_prefix=SCREAMING_SNAKE_CASE_ , ) finally: _lowerCAmelCase = compute_metrics _lowerCAmelCase = self.args.eval_batch_size * self.args.world_size if F'{metric_key_prefix}_jit_compilation_time' in output.metrics: start_time += output.metrics[F'{metric_key_prefix}_jit_compilation_time'] output.metrics.update( speed_metrics( SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , num_samples=output.num_samples , num_steps=math.ceil(output.num_samples / total_batch_size ) , ) ) if self.post_process_function is None or self.compute_metrics is None: return output _lowerCAmelCase = self.post_process_function(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , output.predictions , """predict""" ) _lowerCAmelCase = self.compute_metrics(SCREAMING_SNAKE_CASE_ ) # Prefix all keys with metric_key_prefix + '_' for key in list(metrics.keys() ): if not key.startswith(F'{metric_key_prefix}_' ): _lowerCAmelCase = metrics.pop(SCREAMING_SNAKE_CASE_ ) metrics.update(output.metrics ) return PredictionOutput(predictions=predictions.predictions , label_ids=predictions.label_ids , metrics=SCREAMING_SNAKE_CASE_ )
82
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_speech_available, is_torch_available, ) __a = { 'configuration_trocr': ['TROCR_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TrOCRConfig'], 'processing_trocr': ['TrOCRProcessor'], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __a = [ 'TROCR_PRETRAINED_MODEL_ARCHIVE_LIST', 'TrOCRForCausalLM', 'TrOCRPreTrainedModel', ] if TYPE_CHECKING: from .configuration_trocr import TROCR_PRETRAINED_CONFIG_ARCHIVE_MAP, TrOCRConfig from .processing_trocr import TrOCRProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_trocr import TROCR_PRETRAINED_MODEL_ARCHIVE_LIST, TrOCRForCausalLM, TrOCRPreTrainedModel else: import sys __a = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
30
0
import os from shutil import copyfile from typing import List, Optional, Tuple from ...tokenization_utils import AddedToken from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import is_sentencepiece_available, logging if is_sentencepiece_available(): from .tokenization_barthez import BarthezTokenizer else: lowerCamelCase : Dict =None lowerCamelCase : List[str] =logging.get_logger(__name__) lowerCamelCase : List[str] ={'''vocab_file''': '''sentencepiece.bpe.model''', '''tokenizer_file''': '''tokenizer.json'''} lowerCamelCase : Union[str, Any] ={ '''vocab_file''': { '''moussaKam/mbarthez''': '''https://huggingface.co/moussaKam/mbarthez/resolve/main/sentencepiece.bpe.model''', '''moussaKam/barthez''': '''https://huggingface.co/moussaKam/barthez/resolve/main/sentencepiece.bpe.model''', '''moussaKam/barthez-orangesum-title''': ( '''https://huggingface.co/moussaKam/barthez-orangesum-title/resolve/main/sentencepiece.bpe.model''' ), }, '''tokenizer_file''': { '''moussaKam/mbarthez''': '''https://huggingface.co/moussaKam/mbarthez/resolve/main/tokenizer.json''', '''moussaKam/barthez''': '''https://huggingface.co/moussaKam/barthez/resolve/main/tokenizer.json''', '''moussaKam/barthez-orangesum-title''': ( '''https://huggingface.co/moussaKam/barthez-orangesum-title/resolve/main/tokenizer.json''' ), }, } lowerCamelCase : Dict ={ '''moussaKam/mbarthez''': 1024, '''moussaKam/barthez''': 1024, '''moussaKam/barthez-orangesum-title''': 1024, } lowerCamelCase : Optional[int] ='''▁''' class __a ( A__ ): _lowerCAmelCase : List[str] = VOCAB_FILES_NAMES _lowerCAmelCase : str = PRETRAINED_VOCAB_FILES_MAP _lowerCAmelCase : List[str] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _lowerCAmelCase : str = ['''input_ids''', '''attention_mask'''] _lowerCAmelCase : str = BarthezTokenizer def __init__( self : Tuple , SCREAMING_SNAKE_CASE : Union[str, Any]=None , SCREAMING_SNAKE_CASE : List[Any]=None , SCREAMING_SNAKE_CASE : List[Any]="<s>" , SCREAMING_SNAKE_CASE : Any="</s>" , SCREAMING_SNAKE_CASE : List[str]="</s>" , SCREAMING_SNAKE_CASE : Tuple="<s>" , SCREAMING_SNAKE_CASE : str="<unk>" , SCREAMING_SNAKE_CASE : Optional[int]="<pad>" , SCREAMING_SNAKE_CASE : str="<mask>" , **SCREAMING_SNAKE_CASE : List[Any] , ): '''simple docstring''' UpperCamelCase__ : int = AddedToken(SCREAMING_SNAKE_CASE , lstrip=SCREAMING_SNAKE_CASE , rstrip=SCREAMING_SNAKE_CASE ) if isinstance(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE ) else mask_token super().__init__( SCREAMING_SNAKE_CASE , tokenizer_file=SCREAMING_SNAKE_CASE , bos_token=SCREAMING_SNAKE_CASE , eos_token=SCREAMING_SNAKE_CASE , unk_token=SCREAMING_SNAKE_CASE , sep_token=SCREAMING_SNAKE_CASE , cls_token=SCREAMING_SNAKE_CASE , pad_token=SCREAMING_SNAKE_CASE , mask_token=SCREAMING_SNAKE_CASE , **SCREAMING_SNAKE_CASE , ) UpperCamelCase__ : Union[str, Any] = vocab_file UpperCamelCase__ : List[Any] = False if not self.vocab_file else True def __lowercase ( self : Tuple , SCREAMING_SNAKE_CASE : List[int] , SCREAMING_SNAKE_CASE : Optional[List[int]] = None ): '''simple docstring''' if token_ids_a is None: return [self.cls_token_id] + token_ids_a + [self.sep_token_id] UpperCamelCase__ : Any = [self.cls_token_id] UpperCamelCase__ : int = [self.sep_token_id] return cls + token_ids_a + sep + sep + token_ids_a + sep def __lowercase ( self : List[str] , SCREAMING_SNAKE_CASE : List[int] , SCREAMING_SNAKE_CASE : Optional[List[int]] = None ): '''simple docstring''' UpperCamelCase__ : List[str] = [self.sep_token_id] UpperCamelCase__ : Dict = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0] def __lowercase ( self : int , SCREAMING_SNAKE_CASE : str , SCREAMING_SNAKE_CASE : Optional[str] = None ): '''simple docstring''' if not self.can_save_slow_tokenizer: raise ValueError( "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow " "tokenizer." ) if not os.path.isdir(SCREAMING_SNAKE_CASE ): logger.error(F'Vocabulary path ({save_directory}) should be a directory' ) return UpperCamelCase__ : Any = os.path.join( SCREAMING_SNAKE_CASE , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(SCREAMING_SNAKE_CASE ): copyfile(self.vocab_file , SCREAMING_SNAKE_CASE ) return (out_vocab_file,)
196
import argparse import os import re import packaging.version lowerCamelCase : Optional[Any] ='''examples/''' lowerCamelCase : List[Any] ={ '''examples''': (re.compile(R'''^check_min_version\("[^"]+"\)\s*$''', re.MULTILINE), '''check_min_version("VERSION")\n'''), '''init''': (re.compile(R'''^__version__\s+=\s+"([^"]+)"\s*$''', re.MULTILINE), '''__version__ = "VERSION"\n'''), '''setup''': (re.compile(R'''^(\s*)version\s*=\s*"[^"]+",''', re.MULTILINE), R'''\1version="VERSION",'''), '''doc''': (re.compile(R'''^(\s*)release\s*=\s*"[^"]+"$''', re.MULTILINE), '''release = "VERSION"\n'''), } lowerCamelCase : List[str] ={ '''init''': '''src/transformers/__init__.py''', '''setup''': '''setup.py''', } lowerCamelCase : int ='''README.md''' def SCREAMING_SNAKE_CASE ( __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase ) -> Optional[Any]: with open(__lowerCAmelCase , "r" , encoding="utf-8" , newline="\n" ) as f: UpperCamelCase__ : List[Any] = f.read() UpperCamelCase__ , UpperCamelCase__ : List[str] = REPLACE_PATTERNS[pattern] UpperCamelCase__ : Union[str, Any] = replace.replace("VERSION" , __lowerCAmelCase ) UpperCamelCase__ : Tuple = re_pattern.sub(__lowerCAmelCase , __lowerCAmelCase ) with open(__lowerCAmelCase , "w" , encoding="utf-8" , newline="\n" ) as f: f.write(__lowerCAmelCase ) def SCREAMING_SNAKE_CASE ( __lowerCAmelCase ) -> Union[str, Any]: for folder, directories, fnames in os.walk(__lowerCAmelCase ): # Removing some of the folders with non-actively maintained examples from the walk if "research_projects" in directories: directories.remove("research_projects" ) if "legacy" in directories: directories.remove("legacy" ) for fname in fnames: if fname.endswith(".py" ): update_version_in_file(os.path.join(__lowerCAmelCase , __lowerCAmelCase ) , __lowerCAmelCase , pattern="examples" ) def SCREAMING_SNAKE_CASE ( __lowerCAmelCase , __lowerCAmelCase=False ) -> Optional[int]: for pattern, fname in REPLACE_FILES.items(): update_version_in_file(__lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase ) if not patch: update_version_in_examples(__lowerCAmelCase ) def SCREAMING_SNAKE_CASE ( ) -> Optional[Any]: UpperCamelCase__ : Tuple = "🤗 Transformers currently provides the following architectures" UpperCamelCase__ : Tuple = "1. Want to contribute a new model?" with open(__lowerCAmelCase , "r" , encoding="utf-8" , newline="\n" ) as f: UpperCamelCase__ : Optional[int] = f.readlines() # Find the start of the list. UpperCamelCase__ : List[Any] = 0 while not lines[start_index].startswith(_start_prompt ): start_index += 1 start_index += 1 UpperCamelCase__ : Dict = start_index # Update the lines in the model list. while not lines[index].startswith(_end_prompt ): if lines[index].startswith("1." ): UpperCamelCase__ : str = lines[index].replace( "https://huggingface.co/docs/transformers/main/model_doc" , "https://huggingface.co/docs/transformers/model_doc" , ) index += 1 with open(__lowerCAmelCase , "w" , encoding="utf-8" , newline="\n" ) as f: f.writelines(__lowerCAmelCase ) def SCREAMING_SNAKE_CASE ( ) -> Tuple: with open(REPLACE_FILES["init"] , "r" ) as f: UpperCamelCase__ : str = f.read() UpperCamelCase__ : Dict = REPLACE_PATTERNS["init"][0].search(__lowerCAmelCase ).groups()[0] return packaging.version.parse(__lowerCAmelCase ) def SCREAMING_SNAKE_CASE ( __lowerCAmelCase=False ) -> Optional[int]: UpperCamelCase__ : Dict = get_version() if patch and default_version.is_devrelease: raise ValueError("Can't create a patch version from the dev branch, checkout a released version!" ) if default_version.is_devrelease: UpperCamelCase__ : List[str] = default_version.base_version elif patch: UpperCamelCase__ : int = f'{default_version.major}.{default_version.minor}.{default_version.micro + 1}' else: UpperCamelCase__ : Tuple = f'{default_version.major}.{default_version.minor + 1}.0' # Now let's ask nicely if that's the right one. UpperCamelCase__ : Tuple = input(f'Which version are you releasing? [{default_version}]' ) if len(__lowerCAmelCase ) == 0: UpperCamelCase__ : Any = default_version print(f'Updating version to {version}.' ) global_version_update(__lowerCAmelCase , patch=__lowerCAmelCase ) if not patch: print("Cleaning main README, don't forget to run `make fix-copies`." ) clean_main_ref_in_model_list() def SCREAMING_SNAKE_CASE ( ) -> int: UpperCamelCase__ : str = get_version() UpperCamelCase__ : Dict = f'{current_version.major}.{current_version.minor + 1}.0.dev0' UpperCamelCase__ : int = current_version.base_version # Check with the user we got that right. UpperCamelCase__ : List[str] = input(f'Which version are we developing now? [{dev_version}]' ) if len(__lowerCAmelCase ) == 0: UpperCamelCase__ : Optional[Any] = dev_version print(f'Updating version to {version}.' ) global_version_update(__lowerCAmelCase ) print("Cleaning main README, don't forget to run `make fix-copies`." ) clean_main_ref_in_model_list() if __name__ == "__main__": lowerCamelCase : List[Any] =argparse.ArgumentParser() parser.add_argument('''--post_release''', action='''store_true''', help='''Whether this is pre or post release.''') parser.add_argument('''--patch''', action='''store_true''', help='''Whether or not this is a patch release.''') lowerCamelCase : Optional[Any] =parser.parse_args() if not args.post_release: pre_release_work(patch=args.patch) elif args.patch: print('''Nothing to do after a patch :-)''') else: post_release_work()
196
1
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_speech_available, is_tf_available, is_torch_available, ) __A : Optional[int] = { '''configuration_speech_to_text''': ['''SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''Speech2TextConfig'''], '''processing_speech_to_text''': ['''Speech2TextProcessor'''], } try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A : Tuple = ['''Speech2TextTokenizer'''] try: if not is_speech_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A : List[str] = ['''Speech2TextFeatureExtractor'''] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A : List[Any] = [ '''TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST''', '''TFSpeech2TextForConditionalGeneration''', '''TFSpeech2TextModel''', '''TFSpeech2TextPreTrainedModel''', ] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A : List[Any] = [ '''SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST''', '''Speech2TextForConditionalGeneration''', '''Speech2TextModel''', '''Speech2TextPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_speech_to_text import SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextConfig from .processing_speech_to_text import SpeechaTextProcessor try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_speech_to_text import SpeechaTextTokenizer try: if not is_speech_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_speech_to_text import SpeechaTextFeatureExtractor try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_speech_to_text import ( TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST, TFSpeechaTextForConditionalGeneration, TFSpeechaTextModel, TFSpeechaTextPreTrainedModel, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_speech_to_text import ( SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST, SpeechaTextForConditionalGeneration, SpeechaTextModel, SpeechaTextPreTrainedModel, ) else: import sys __A : int = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
33
'''simple docstring''' from ..utils import ( OptionalDependencyNotAvailable, is_flax_available, is_scipy_available, is_torch_available, is_torchsde_available, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_pt_objects import * # noqa F403 else: from .scheduling_consistency_models import CMStochasticIterativeScheduler from .scheduling_ddim import DDIMScheduler from .scheduling_ddim_inverse import DDIMInverseScheduler from .scheduling_ddim_parallel import DDIMParallelScheduler from .scheduling_ddpm import DDPMScheduler from .scheduling_ddpm_parallel import DDPMParallelScheduler from .scheduling_deis_multistep import DEISMultistepScheduler from .scheduling_dpmsolver_multistep import DPMSolverMultistepScheduler from .scheduling_dpmsolver_multistep_inverse import DPMSolverMultistepInverseScheduler from .scheduling_dpmsolver_singlestep import DPMSolverSinglestepScheduler from .scheduling_euler_ancestral_discrete import EulerAncestralDiscreteScheduler from .scheduling_euler_discrete import EulerDiscreteScheduler from .scheduling_heun_discrete import HeunDiscreteScheduler from .scheduling_ipndm import IPNDMScheduler from .scheduling_k_dpm_2_ancestral_discrete import KDPMaAncestralDiscreteScheduler from .scheduling_k_dpm_2_discrete import KDPMaDiscreteScheduler from .scheduling_karras_ve import KarrasVeScheduler from .scheduling_pndm import PNDMScheduler from .scheduling_repaint import RePaintScheduler from .scheduling_sde_ve import ScoreSdeVeScheduler from .scheduling_sde_vp import ScoreSdeVpScheduler from .scheduling_unclip import UnCLIPScheduler from .scheduling_unipc_multistep import UniPCMultistepScheduler from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin from .scheduling_vq_diffusion import VQDiffusionScheduler try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_flax_objects import * # noqa F403 else: from .scheduling_ddim_flax import FlaxDDIMScheduler from .scheduling_ddpm_flax import FlaxDDPMScheduler from .scheduling_dpmsolver_multistep_flax import FlaxDPMSolverMultistepScheduler from .scheduling_karras_ve_flax import FlaxKarrasVeScheduler from .scheduling_lms_discrete_flax import FlaxLMSDiscreteScheduler from .scheduling_pndm_flax import FlaxPNDMScheduler from .scheduling_sde_ve_flax import FlaxScoreSdeVeScheduler from .scheduling_utils_flax import ( FlaxKarrasDiffusionSchedulers, FlaxSchedulerMixin, FlaxSchedulerOutput, broadcast_to_shape_from_left, ) try: if not (is_torch_available() and is_scipy_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_torch_and_scipy_objects import * # noqa F403 else: from .scheduling_lms_discrete import LMSDiscreteScheduler try: if not (is_torch_available() and is_torchsde_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_torch_and_torchsde_objects import * # noqa F403 else: from .scheduling_dpmsolver_sde import DPMSolverSDEScheduler
22
0
'''simple docstring''' # # This a `torch.distributed` diagnostics script that checks that all GPUs in the cluster (one or # many nodes) can talk to each other via nccl and allocate gpu memory. # # To run first adjust the number of processes and nodes: # # python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py # # You may need to add --master_addr $MASTER_ADDR --master_port $MASTER_PORT if using a custom addr:port # # You can also use the rdzv API: --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT --rdzv_backend c10d # # use torch.distributed.launch instead of torch.distributed.run for torch < 1.9 # # If you get a hanging in `barrier` calls you have some network issues, you may try to debug this with: # # NCCL_DEBUG=INFO python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py # # which should tell you what's going on behind the scenes. # # # This script can be run via `srun` in the SLURM environment as well. Here is a SLURM script that # runs on 2 nodes of 4 gpus per node: # # #SBATCH --job-name=test-nodes # name # #SBATCH --nodes=2 # nodes # #SBATCH --ntasks-per-node=1 # crucial - only 1 task per dist per node! # #SBATCH --cpus-per-task=10 # number of cores per tasks # #SBATCH --gres=gpu:4 # number of gpus # #SBATCH --time 0:05:00 # maximum execution time (HH:MM:SS) # #SBATCH --output=%x-%j.out # output file name # # GPUS_PER_NODE=4 # MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1) # MASTER_PORT=6000 # # srun --jobid $SLURM_JOBID bash -c 'python -m torch.distributed.run \ # --nproc_per_node $GPUS_PER_NODE --nnodes $SLURM_NNODES --node_rank $SLURM_PROCID \ # --master_addr $MASTER_ADDR --master_port $MASTER_PORT \ # torch-distributed-gpu-test.py' # import fcntl import os import socket import torch import torch.distributed as dist def __UpperCamelCase ( *_UpperCAmelCase ): with open(_UpperCAmelCase, "r" ) as fh: fcntl.flock(_UpperCAmelCase, fcntl.LOCK_EX ) try: print(*_UpperCAmelCase ) finally: fcntl.flock(_UpperCAmelCase, fcntl.LOCK_UN ) lowerCAmelCase__ : Dict = int(os.environ["LOCAL_RANK"]) torch.cuda.set_device(local_rank) lowerCAmelCase__ : Optional[int] = torch.device("cuda", local_rank) lowerCAmelCase__ : List[str] = socket.gethostname() lowerCAmelCase__ : Optional[Any] = f"[{hostname}-{local_rank}]" try: # test distributed dist.init_process_group("nccl") dist.all_reduce(torch.ones(1).to(device), op=dist.ReduceOp.SUM) dist.barrier() # test cuda is available and can allocate memory torch.cuda.is_available() torch.ones(1).cuda(local_rank) # global rank lowerCAmelCase__ : Tuple = dist.get_rank() lowerCAmelCase__ : Optional[int] = dist.get_world_size() printflock(f"{gpu} is OK (global rank: {rank}/{world_size})") dist.barrier() if rank == 0: printflock(f"pt={torch.__version__}, cuda={torch.version.cuda}, nccl={torch.cuda.nccl.version()}") except Exception: printflock(f"{gpu} is broken") raise
37
'''simple docstring''' # Copyright 2022 The HuggingFace Team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import argparse import os import platform import numpy as np import psutil import torch from accelerate import __version__ as version from accelerate.commands.config import default_config_file, load_config_from_file from ..utils import is_npu_available, is_xpu_available def __UpperCamelCase ( _UpperCAmelCase=None ): if subparsers is not None: __UpperCAmelCase : Optional[int] = subparsers.add_parser("env" ) else: __UpperCAmelCase : List[Any] = argparse.ArgumentParser("Accelerate env command" ) parser.add_argument( "--config_file", default=_UpperCAmelCase, help="The config file to use for the default values in the launching script." ) if subparsers is not None: parser.set_defaults(func=_UpperCAmelCase ) return parser def __UpperCamelCase ( _UpperCAmelCase ): __UpperCAmelCase : Dict = torch.__version__ __UpperCAmelCase : str = torch.cuda.is_available() __UpperCAmelCase : str = is_xpu_available() __UpperCAmelCase : List[Any] = is_npu_available() __UpperCAmelCase : Union[str, Any] = "Not found" # Get the default from the config file. if args.config_file is not None or os.path.isfile(_UpperCAmelCase ): __UpperCAmelCase : Union[str, Any] = load_config_from_file(args.config_file ).to_dict() __UpperCAmelCase : List[str] = { "`Accelerate` version": version, "Platform": platform.platform(), "Python version": platform.python_version(), "Numpy version": np.__version__, "PyTorch version (GPU?)": F"{pt_version} ({pt_cuda_available})", "PyTorch XPU available": str(_UpperCAmelCase ), "PyTorch NPU available": str(_UpperCAmelCase ), "System RAM": F"{psutil.virtual_memory().total / 1024 ** 3:.2f} GB", } if pt_cuda_available: __UpperCAmelCase : int = torch.cuda.get_device_name() print("\nCopy-and-paste the text below in your GitHub issue\n" ) print("\n".join([F"- {prop}: {val}" for prop, val in info.items()] ) ) print("- `Accelerate` default config:" if args.config_file is None else "- `Accelerate` config passed:" ) __UpperCAmelCase : Tuple = ( "\n".join([F"\t- {prop}: {val}" for prop, val in accelerate_config.items()] ) if isinstance(_UpperCAmelCase, _UpperCAmelCase ) else F"\t{accelerate_config}" ) print(_UpperCAmelCase ) __UpperCAmelCase : Any = accelerate_config return info def __UpperCamelCase ( ): __UpperCAmelCase : Tuple = env_command_parser() __UpperCAmelCase : Dict = parser.parse_args() env_command(_UpperCAmelCase ) return 0 if __name__ == "__main__": raise SystemExit(main())
37
1
from transformers import DistilBertTokenizer, DistilBertTokenizerFast from transformers.testing_utils import require_tokenizers, slow from ..bert.test_tokenization_bert import BertTokenizationTest @require_tokenizers class __lowerCAmelCase ( __magic_name__ ): """simple docstring""" snake_case_ = DistilBertTokenizer snake_case_ = DistilBertTokenizerFast snake_case_ = True @slow def lowercase_ ( self ) -> List[Any]: '''simple docstring''' __lowerCamelCase = DistilBertTokenizer.from_pretrained('distilbert-base-uncased' ) __lowerCamelCase = tokenizer.encode('sequence builders' , add_special_tokens=lowerCamelCase__ ) __lowerCamelCase = tokenizer.encode('multi-sequence build' , add_special_tokens=lowerCamelCase__ ) __lowerCamelCase = tokenizer.build_inputs_with_special_tokens(lowerCamelCase__ ) __lowerCamelCase = tokenizer.build_inputs_with_special_tokens(lowerCamelCase__ , lowerCamelCase__ ) assert encoded_sentence == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] assert encoded_pair == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [ tokenizer.sep_token_id ]
90
import itertools from dataclasses import dataclass from typing import Any, Callable, Dict, List, Optional, Union import pandas as pd import pyarrow as pa import datasets import datasets.config from datasets.features.features import require_storage_cast from datasets.table import table_cast from datasets.utils.py_utils import Literal lowerCamelCase = datasets.utils.logging.get_logger(__name__) lowerCamelCase = ['names', 'prefix'] lowerCamelCase = ['warn_bad_lines', 'error_bad_lines', 'mangle_dupe_cols'] lowerCamelCase = ['encoding_errors', 'on_bad_lines'] lowerCamelCase = ['date_format'] @dataclass class A ( datasets.BuilderConfig ): UpperCamelCase__ : str ="," UpperCamelCase__ : Optional[str] =None UpperCamelCase__ : Optional[Union[int, List[int], str]] ="infer" UpperCamelCase__ : Optional[List[str]] =None UpperCamelCase__ : Optional[List[str]] =None UpperCamelCase__ : Optional[Union[int, str, List[int], List[str]]] =None UpperCamelCase__ : Optional[Union[List[int], List[str]]] =None UpperCamelCase__ : Optional[str] =None UpperCamelCase__ : bool =True UpperCamelCase__ : Optional[Literal["c", "python", "pyarrow"]] =None UpperCamelCase__ : Dict[Union[int, str], Callable[[Any], Any]] =None UpperCamelCase__ : Optional[list] =None UpperCamelCase__ : Optional[list] =None UpperCamelCase__ : bool =False UpperCamelCase__ : Optional[Union[int, List[int]]] =None UpperCamelCase__ : Optional[int] =None UpperCamelCase__ : Optional[Union[str, List[str]]] =None UpperCamelCase__ : bool =True UpperCamelCase__ : bool =True UpperCamelCase__ : bool =False UpperCamelCase__ : bool =True UpperCamelCase__ : Optional[str] =None UpperCamelCase__ : str ="." UpperCamelCase__ : Optional[str] =None UpperCamelCase__ : str ='"' UpperCamelCase__ : int =0 UpperCamelCase__ : Optional[str] =None UpperCamelCase__ : Optional[str] =None UpperCamelCase__ : Optional[str] =None UpperCamelCase__ : Optional[str] =None UpperCamelCase__ : bool =True UpperCamelCase__ : bool =True UpperCamelCase__ : int =0 UpperCamelCase__ : bool =True UpperCamelCase__ : bool =False UpperCamelCase__ : Optional[str] =None UpperCamelCase__ : int =10000 UpperCamelCase__ : Optional[datasets.Features] =None UpperCamelCase__ : Optional[str] ="strict" UpperCamelCase__ : Literal["error", "warn", "skip"] ="error" UpperCamelCase__ : Optional[str] =None def lowerCamelCase ( self : List[str] ) -> str: """simple docstring""" if self.delimiter is not None: _lowerCamelCase : Union[str, Any] =self.delimiter if self.column_names is not None: _lowerCamelCase : Dict =self.column_names @property def lowerCamelCase ( self : int ) -> int: """simple docstring""" _lowerCamelCase : Any ={ 'sep': self.sep, 'header': self.header, 'names': self.names, 'index_col': self.index_col, 'usecols': self.usecols, 'prefix': self.prefix, 'mangle_dupe_cols': self.mangle_dupe_cols, 'engine': self.engine, 'converters': self.converters, 'true_values': self.true_values, 'false_values': self.false_values, 'skipinitialspace': self.skipinitialspace, 'skiprows': self.skiprows, 'nrows': self.nrows, 'na_values': self.na_values, 'keep_default_na': self.keep_default_na, 'na_filter': self.na_filter, 'verbose': self.verbose, 'skip_blank_lines': self.skip_blank_lines, 'thousands': self.thousands, 'decimal': self.decimal, 'lineterminator': self.lineterminator, 'quotechar': self.quotechar, 'quoting': self.quoting, 'escapechar': self.escapechar, 'comment': self.comment, 'encoding': self.encoding, 'dialect': self.dialect, 'error_bad_lines': self.error_bad_lines, 'warn_bad_lines': self.warn_bad_lines, 'skipfooter': self.skipfooter, 'doublequote': self.doublequote, 'memory_map': self.memory_map, 'float_precision': self.float_precision, 'chunksize': self.chunksize, 'encoding_errors': self.encoding_errors, 'on_bad_lines': self.on_bad_lines, 'date_format': self.date_format, } # some kwargs must not be passed if they don't have a default value # some others are deprecated and we can also not pass them if they are the default value for pd_read_csv_parameter in _PANDAS_READ_CSV_NO_DEFAULT_PARAMETERS + _PANDAS_READ_CSV_DEPRECATED_PARAMETERS: if pd_read_csv_kwargs[pd_read_csv_parameter] == getattr(CsvConfig() , lowercase_ ): del pd_read_csv_kwargs[pd_read_csv_parameter] # Remove 2.0 new arguments if not (datasets.config.PANDAS_VERSION.major >= 2): for pd_read_csv_parameter in _PANDAS_READ_CSV_NEW_2_0_0_PARAMETERS: del pd_read_csv_kwargs[pd_read_csv_parameter] # Remove 1.3 new arguments if not (datasets.config.PANDAS_VERSION.major >= 1 and datasets.config.PANDAS_VERSION.minor >= 3): for pd_read_csv_parameter in _PANDAS_READ_CSV_NEW_1_3_0_PARAMETERS: del pd_read_csv_kwargs[pd_read_csv_parameter] return pd_read_csv_kwargs class A ( datasets.ArrowBasedBuilder ): UpperCamelCase__ : List[str] =CsvConfig def lowerCamelCase ( self : Any ) -> Tuple: """simple docstring""" return datasets.DatasetInfo(features=self.config.features ) def lowerCamelCase ( self : Tuple , lowercase_ : Any ) -> List[Any]: """simple docstring""" if not self.config.data_files: raise ValueError(F'''At least one data file must be specified, but got data_files={self.config.data_files}''' ) _lowerCamelCase : int =dl_manager.download_and_extract(self.config.data_files ) if isinstance(lowercase_ , (str, list, tuple) ): _lowerCamelCase : List[Any] =data_files if isinstance(lowercase_ , lowercase_ ): _lowerCamelCase : Union[str, Any] =[files] _lowerCamelCase : Union[str, Any] =[dl_manager.iter_files(lowercase_ ) for file in files] return [datasets.SplitGenerator(name=datasets.Split.TRAIN , gen_kwargs={'files': files} )] _lowerCamelCase : Optional[int] =[] for split_name, files in data_files.items(): if isinstance(lowercase_ , lowercase_ ): _lowerCamelCase : Dict =[files] _lowerCamelCase : Optional[int] =[dl_manager.iter_files(lowercase_ ) for file in files] splits.append(datasets.SplitGenerator(name=lowercase_ , gen_kwargs={'files': files} ) ) return splits def lowerCamelCase ( self : int , lowercase_ : pa.Table ) -> pa.Table: """simple docstring""" if self.config.features is not None: _lowerCamelCase : List[str] =self.config.features.arrow_schema if all(not require_storage_cast(lowercase_ ) for feature in self.config.features.values() ): # cheaper cast _lowerCamelCase : Optional[int] =pa.Table.from_arrays([pa_table[field.name] for field in schema] , schema=lowercase_ ) else: # more expensive cast; allows str <-> int/float or str to Audio for example _lowerCamelCase : List[Any] =table_cast(lowercase_ , lowercase_ ) return pa_table def lowerCamelCase ( self : Optional[Any] , lowercase_ : List[Any] ) -> Any: """simple docstring""" _lowerCamelCase : str =self.config.features.arrow_schema if self.config.features else None # dtype allows reading an int column as str _lowerCamelCase : Union[str, Any] =( { name: dtype.to_pandas_dtype() if not require_storage_cast(lowercase_ ) else object for name, dtype, feature in zip(schema.names , schema.types , self.config.features.values() ) } if schema is not None else None ) for file_idx, file in enumerate(itertools.chain.from_iterable(lowercase_ ) ): _lowerCamelCase : Union[str, Any] =pd.read_csv(lowercase_ , iterator=lowercase_ , dtype=lowercase_ , **self.config.pd_read_csv_kwargs ) try: for batch_idx, df in enumerate(lowercase_ ): _lowerCamelCase : Tuple =pa.Table.from_pandas(lowercase_ ) # Uncomment for debugging (will print the Arrow table size and elements) # logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}") # logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows))) yield (file_idx, batch_idx), self._cast_table(lowercase_ ) except ValueError as e: logger.error(F'''Failed to read file \'{file}\' with error {type(lowercase_ )}: {e}''' ) raise
199
0
_lowerCamelCase : List[Any] = """ # Transformers installation ! pip install transformers datasets # To install from source instead of the last release, comment the command above and uncomment the following one. # ! pip install git+https://github.com/huggingface/transformers.git """ _lowerCamelCase : str = [{"""type""": """code""", """content""": INSTALL_CONTENT}] _lowerCamelCase : Optional[Any] = { """{processor_class}""": """FakeProcessorClass""", """{model_class}""": """FakeModelClass""", """{object_class}""": """FakeObjectClass""", }
231
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_speech_available, is_torch_available, ) _lowerCamelCase : Optional[Any] = { """configuration_trocr""": ["""TROCR_PRETRAINED_CONFIG_ARCHIVE_MAP""", """TrOCRConfig"""], """processing_trocr""": ["""TrOCRProcessor"""], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCamelCase : Any = [ """TROCR_PRETRAINED_MODEL_ARCHIVE_LIST""", """TrOCRForCausalLM""", """TrOCRPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_trocr import TROCR_PRETRAINED_CONFIG_ARCHIVE_MAP, TrOCRConfig from .processing_trocr import TrOCRProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_trocr import TROCR_PRETRAINED_MODEL_ARCHIVE_LIST, TrOCRForCausalLM, TrOCRPreTrainedModel else: import sys _lowerCamelCase : List[str] = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
231
1
'''simple docstring''' import copy from typing import Dict, Optional from ...configuration_utils import PretrainedConfig from ...utils import logging from ..auto import CONFIG_MAPPING from ..detr import DetrConfig from ..swin import SwinConfig A__ : List[str] ={ '''facebook/maskformer-swin-base-ade''': ( '''https://huggingface.co/facebook/maskformer-swin-base-ade/blob/main/config.json''' ) # See all MaskFormer models at https://huggingface.co/models?filter=maskformer } A__ : List[str] =logging.get_logger(__name__) class UpperCAmelCase ( snake_case_ ): _lowercase: Tuple = '''maskformer''' _lowercase: List[Any] = {'''hidden_size''': '''mask_feature_size'''} _lowercase: List[str] = ['''resnet''', '''swin'''] _lowercase: int = ['''detr'''] def __init__( self : List[str] , __snake_case : int = 2_56 , __snake_case : int = 2_56 , __snake_case : float = 0.1 , __snake_case : bool = False , __snake_case : Optional[Dict] = None , __snake_case : Optional[Dict] = None , __snake_case : float = 0.02 , __snake_case : float = 1.0 , __snake_case : float = 1.0 , __snake_case : float = 1.0 , __snake_case : float = 20.0 , __snake_case : Optional[bool] = None , **__snake_case : List[Any] , ) -> int: if backbone_config is None: # fall back to https://huggingface.co/microsoft/swin-base-patch4-window12-384-in22k _lowerCAmelCase = SwinConfig( image_size=3_84 , in_channels=3 , patch_size=4 , embed_dim=1_28 , depths=[2, 2, 18, 2] , num_heads=[4, 8, 16, 32] , window_size=12 , drop_path_rate=0.3 , out_features=["""stage1""", """stage2""", """stage3""", """stage4"""] , ) if isinstance(__snake_case , __snake_case ): _lowerCAmelCase = backbone_config.pop("""model_type""" ) _lowerCAmelCase = CONFIG_MAPPING[backbone_model_type] _lowerCAmelCase = config_class.from_dict(__snake_case ) # verify that the backbone is supported if backbone_config.model_type not in self.backbones_supported: logger.warning_once( f"Backbone {backbone_config.model_type} is not a supported model and may not be compatible with MaskFormer. " f"Supported model types: {','.join(self.backbones_supported )}" ) if decoder_config is None: # fall back to https://huggingface.co/facebook/detr-resnet-50 _lowerCAmelCase = DetrConfig() else: # verify that the decoder is supported _lowerCAmelCase = ( decoder_config.pop("""model_type""" ) if isinstance(__snake_case , __snake_case ) else decoder_config.model_type ) if decoder_type not in self.decoders_supported: raise ValueError( f"Transformer Decoder {decoder_type} not supported, please use one of" f" {','.join(self.decoders_supported )}" ) if isinstance(__snake_case , __snake_case ): _lowerCAmelCase = CONFIG_MAPPING[decoder_type] _lowerCAmelCase = config_class.from_dict(__snake_case ) _lowerCAmelCase = backbone_config _lowerCAmelCase = decoder_config # main feature dimension for the model _lowerCAmelCase = fpn_feature_size _lowerCAmelCase = mask_feature_size # initializer _lowerCAmelCase = init_std _lowerCAmelCase = init_xavier_std # Hungarian matcher && loss _lowerCAmelCase = cross_entropy_weight _lowerCAmelCase = dice_weight _lowerCAmelCase = mask_weight _lowerCAmelCase = use_auxiliary_loss _lowerCAmelCase = no_object_weight _lowerCAmelCase = output_auxiliary_logits _lowerCAmelCase = self.decoder_config.encoder_attention_heads _lowerCAmelCase = self.decoder_config.num_hidden_layers super().__init__(**__snake_case ) @classmethod def lowercase__ ( cls : Optional[int] , __snake_case : PretrainedConfig , __snake_case : PretrainedConfig , **__snake_case : int ) -> Union[str, Any]: return cls( backbone_config=__snake_case , decoder_config=__snake_case , **__snake_case , ) def lowercase__ ( self : Union[str, Any] ) -> Dict[str, any]: _lowerCAmelCase = copy.deepcopy(self.__dict__ ) _lowerCAmelCase = self.backbone_config.to_dict() _lowerCAmelCase = self.decoder_config.to_dict() _lowerCAmelCase = self.__class__.model_type return output
70
"""simple docstring""" from transformers import HfArgumentParser, TensorFlowBenchmark, TensorFlowBenchmarkArguments def UpperCAmelCase ( ) -> int: snake_case_ = HfArgumentParser(UpperCAmelCase ) snake_case_ = parser.parse_args_into_dataclasses()[0] snake_case_ = TensorFlowBenchmark(args=UpperCAmelCase ) try: snake_case_ = parser.parse_args_into_dataclasses()[0] except ValueError as e: snake_case_ = 'Arg --no_{0} is no longer used, please use --no-{0} instead.' snake_case_ = ' '.join(str(UpperCAmelCase ).split(' ' )[:-1] ) snake_case_ = '' snake_case_ = eval(str(UpperCAmelCase ).split(' ' )[-1] ) snake_case_ = [] for arg in depreciated_args: # arg[2:] removes '--' if arg[2:] in TensorFlowBenchmark.deprecated_args: # arg[5:] removes '--no_' full_error_msg += arg_error_msg.format(arg[5:] ) else: wrong_args.append(UpperCAmelCase ) if len(UpperCAmelCase ) > 0: snake_case_ = full_error_msg + begin_error_msg + str(UpperCAmelCase ) raise ValueError(UpperCAmelCase ) benchmark.run() if __name__ == "__main__": main()
69
0
import argparse import json from pathlib import Path import requests import torch from huggingface_hub import hf_hub_download from PIL import Image from timm import create_model from timm.data import resolve_data_config from timm.data.transforms_factory import create_transform from transformers import BitConfig, BitForImageClassification, BitImageProcessor from transformers.image_utils import PILImageResampling from transformers.utils import logging logging.set_verbosity_info() lowercase_ = logging.get_logger(__name__) def __lowerCAmelCase ( SCREAMING_SNAKE_CASE_ ): lowercase__ = "huggingface/label-files" lowercase__ = "imagenet-1k-id2label.json" lowercase__ = json.load(open(hf_hub_download(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , repo_type="dataset" ) , "r" ) ) lowercase__ = {int(SCREAMING_SNAKE_CASE_ ): v for k, v in idalabel.items()} lowercase__ = {v: k for k, v in idalabel.items()} lowercase__ = "std_conv" if "bit" in model_name else False # note that when using BiT as backbone for ViT-hybrid checkpoints, # one needs to additionally set config.layer_type = "bottleneck", config.stem_type = "same", # config.conv_layer = "std_conv_same" lowercase__ = BitConfig( conv_layer=SCREAMING_SNAKE_CASE_ , num_labels=1000 , idalabel=SCREAMING_SNAKE_CASE_ , labelaid=SCREAMING_SNAKE_CASE_ , ) return config def __lowerCAmelCase ( SCREAMING_SNAKE_CASE_ ): if "stem.conv" in name: lowercase__ = name.replace("stem.conv" , "bit.embedder.convolution" ) if "blocks" in name: lowercase__ = name.replace("blocks" , "layers" ) if "head.fc" in name: lowercase__ = name.replace("head.fc" , "classifier.1" ) if name.startswith("norm" ): lowercase__ = "bit." + name if "bit" not in name and "classifier" not in name: lowercase__ = "bit.encoder." + name return name def __lowerCAmelCase ( ): lowercase__ = "http://images.cocodataset.org/val2017/000000039769.jpg" lowercase__ = Image.open(requests.get(SCREAMING_SNAKE_CASE_ , stream=SCREAMING_SNAKE_CASE_ ).raw ) return im @torch.no_grad() def __lowerCAmelCase ( SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_=False ): lowercase__ = get_config(SCREAMING_SNAKE_CASE_ ) # load original model from timm lowercase__ = create_model(SCREAMING_SNAKE_CASE_ , pretrained=SCREAMING_SNAKE_CASE_ ) timm_model.eval() # load state_dict of original model lowercase__ = timm_model.state_dict() for key in state_dict.copy().keys(): lowercase__ = state_dict.pop(SCREAMING_SNAKE_CASE_ ) lowercase__ = val.squeeze() if "head" in key else val # load HuggingFace model lowercase__ = BitForImageClassification(SCREAMING_SNAKE_CASE_ ) model.eval() model.load_state_dict(SCREAMING_SNAKE_CASE_ ) # create image processor lowercase__ = create_transform(**resolve_data_config({} , model=SCREAMING_SNAKE_CASE_ ) ) lowercase__ = transform.transforms lowercase__ = { "bilinear": PILImageResampling.BILINEAR, "bicubic": PILImageResampling.BICUBIC, "nearest": PILImageResampling.NEAREST, } lowercase__ = BitImageProcessor( do_resize=SCREAMING_SNAKE_CASE_ , size={"shortest_edge": timm_transforms[0].size} , resample=pillow_resamplings[timm_transforms[0].interpolation.value] , do_center_crop=SCREAMING_SNAKE_CASE_ , crop_size={"height": timm_transforms[1].size[0], "width": timm_transforms[1].size[1]} , do_normalize=SCREAMING_SNAKE_CASE_ , image_mean=timm_transforms[-1].mean.tolist() , image_std=timm_transforms[-1].std.tolist() , ) lowercase__ = prepare_img() lowercase__ = transform(SCREAMING_SNAKE_CASE_ ).unsqueeze(0 ) lowercase__ = processor(SCREAMING_SNAKE_CASE_ , return_tensors="pt" ).pixel_values # verify pixel values assert torch.allclose(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ) # verify logits with torch.no_grad(): lowercase__ = model(SCREAMING_SNAKE_CASE_ ) lowercase__ = outputs.logits print("Logits:" , logits[0, :3] ) print("Predicted class:" , model.config.idalabel[logits.argmax(-1 ).item()] ) lowercase__ = timm_model(SCREAMING_SNAKE_CASE_ ) assert timm_logits.shape == outputs.logits.shape assert torch.allclose(SCREAMING_SNAKE_CASE_ , outputs.logits , atol=1e-3 ) print("Looks ok!" ) if pytorch_dump_folder_path is not None: Path(SCREAMING_SNAKE_CASE_ ).mkdir(exist_ok=SCREAMING_SNAKE_CASE_ ) print(f'''Saving model {model_name} and processor to {pytorch_dump_folder_path}''' ) model.save_pretrained(SCREAMING_SNAKE_CASE_ ) processor.save_pretrained(SCREAMING_SNAKE_CASE_ ) if push_to_hub: print(f'''Pushing model {model_name} and processor to the hub''' ) model.push_to_hub(f'''ybelkada/{model_name}''' ) processor.push_to_hub(f'''ybelkada/{model_name}''' ) if __name__ == "__main__": lowercase_ = argparse.ArgumentParser() # Required parameters parser.add_argument( """--model_name""", default="""resnetv2_50x1_bitm""", type=str, help="""Name of the BiT timm model you'd like to convert.""", ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory.""" ) parser.add_argument( """--push_to_hub""", action="""store_true""", help="""Whether to push the model to the hub.""", ) lowercase_ = parser.parse_args() convert_bit_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
224
from math import sqrt import numpy as np from sympy import symbols # Coefficient # Speed of light (m/s) lowercase_ = 2_9979_2458 # Symbols lowercase_ , lowercase_ , lowercase_ , lowercase_ = symbols("""ct x y z""") def __lowerCAmelCase ( SCREAMING_SNAKE_CASE_ ): if velocity > c: raise ValueError("Speed must not exceed light speed 299,792,458 [m/s]!" ) elif velocity < 1: # Usually the speed should be much higher than 1 (c order of magnitude) raise ValueError("Speed must be greater than or equal to 1!" ) return velocity / c def __lowerCAmelCase ( SCREAMING_SNAKE_CASE_ ): return 1 / sqrt(1 - beta(SCREAMING_SNAKE_CASE_ ) ** 2 ) def __lowerCAmelCase ( SCREAMING_SNAKE_CASE_ ): return np.array( [ [gamma(SCREAMING_SNAKE_CASE_ ), -gamma(SCREAMING_SNAKE_CASE_ ) * beta(SCREAMING_SNAKE_CASE_ ), 0, 0], [-gamma(SCREAMING_SNAKE_CASE_ ) * beta(SCREAMING_SNAKE_CASE_ ), gamma(SCREAMING_SNAKE_CASE_ ), 0, 0], [0, 0, 1, 0], [0, 0, 0, 1], ] ) def __lowerCAmelCase ( SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ = None ): # Ensure event is not empty if event is None: lowercase__ = np.array([ct, x, y, z] ) # Symbolic four vector else: event[0] *= c # x0 is ct (speed of light * time) return transformation_matrix(SCREAMING_SNAKE_CASE_ ) @ event if __name__ == "__main__": import doctest doctest.testmod() # Example of symbolic vector: lowercase_ = transform(2997_9245) print("""Example of four vector: """) print(F'ct\' = {four_vector[0]}') print(F'x\' = {four_vector[1]}') print(F'y\' = {four_vector[2]}') print(F'z\' = {four_vector[3]}') # Substitute symbols with numerical values lowercase_ = {ct: c, x: 1, y: 1, z: 1} lowercase_ = [four_vector[i].subs(sub_dict) for i in range(4)] print(F'\n{numerical_vector}')
224
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, ) a_ = { 'configuration_resnet': ['RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ResNetConfig', 'ResNetOnnxConfig'] } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a_ = [ 'RESNET_PRETRAINED_MODEL_ARCHIVE_LIST', 'ResNetForImageClassification', 'ResNetModel', 'ResNetPreTrainedModel', 'ResNetBackbone', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a_ = [ 'TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST', 'TFResNetForImageClassification', 'TFResNetModel', 'TFResNetPreTrainedModel', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a_ = [ 'FlaxResNetForImageClassification', 'FlaxResNetModel', 'FlaxResNetPreTrainedModel', ] if TYPE_CHECKING: from .configuration_resnet import RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP, ResNetConfig, ResNetOnnxConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_resnet import ( RESNET_PRETRAINED_MODEL_ARCHIVE_LIST, ResNetBackbone, ResNetForImageClassification, ResNetModel, ResNetPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_resnet import ( TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFResNetForImageClassification, TFResNetModel, TFResNetPreTrainedModel, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_resnet import FlaxResNetForImageClassification, FlaxResNetModel, FlaxResNetPreTrainedModel else: import sys a_ = _LazyModule(__name__, globals()['__file__'], _import_structure)
175
'''simple docstring''' def _UpperCAmelCase ( _lowerCamelCase : list[int] , _lowerCamelCase : str ) -> list[int]: _lowerCAmelCase : List[Any] = int(_lowerCamelCase ) # Initialize Result _lowerCAmelCase : Any = [] # Traverse through all denomination for denomination in reversed(_lowerCamelCase ): # Find denominations while int(_lowerCamelCase ) >= int(_lowerCamelCase ): total_value -= int(_lowerCamelCase ) answer.append(_lowerCamelCase ) # Append the "answers" array return answer # Driver Code if __name__ == "__main__": UpperCamelCase_ = [] UpperCamelCase_ = """0""" if ( input("""Do you want to enter your denominations ? (yY/n): """).strip().lower() == "y" ): UpperCamelCase_ = int(input("""Enter the number of denominations you want to add: """).strip()) for i in range(0, n): denominations.append(int(input(F'Denomination {i}: ').strip())) UpperCamelCase_ = input("""Enter the change you want to make in Indian Currency: """).strip() else: # All denominations of Indian Currency if user does not enter UpperCamelCase_ = [1, 2, 5, 10, 20, 50, 1_00, 5_00, 20_00] UpperCamelCase_ = input("""Enter the change you want to make: """).strip() if int(value) == 0 or int(value) < 0: print("""The total value cannot be zero or negative.""") else: print(F'Following is minimal change for {value}: ') UpperCamelCase_ = find_minimum_change(denominations, value) # Print result for i in range(len(answer)): print(answer[i], end=""" """)
309
0
"""simple docstring""" import logging from pathlib import Path import numpy as np import pytorch_lightning as pl import torch from pytorch_lightning.callbacks import EarlyStopping, ModelCheckpoint from pytorch_lightning.utilities import rank_zero_only from utils_rag import save_json def _snake_case ( lowerCamelCase__ : Dict ) -> Any: lowerCamelCase_ : int =filter(lambda lowerCamelCase__ : p.requires_grad , model.parameters() ) lowerCamelCase_ : int =sum([np.prod(p.size() ) for p in model_parameters] ) return params A__ : Union[str, Any] = logging.getLogger(__name__) def _snake_case ( lowerCamelCase__ : Tuple , lowerCamelCase__ : Union[str, Any] ) -> List[Any]: if metric == "rouge2": lowerCamelCase_ : Optional[Any] ="{val_avg_rouge2:.4f}-{step_count}" elif metric == "bleu": lowerCamelCase_ : int ="{val_avg_bleu:.4f}-{step_count}" elif metric == "em": lowerCamelCase_ : List[str] ="{val_avg_em:.4f}-{step_count}" else: raise NotImplementedError( F"""seq2seq callbacks only support rouge2 and bleu, got {metric}, You can make your own by adding to this""" " function." ) lowerCamelCase_ : Optional[Any] =ModelCheckpoint( dirpath=lowerCamelCase__ , filename=lowerCamelCase__ , monitor=F"""val_{metric}""" , mode="max" , save_top_k=3 , every_n_epochs=1 , ) return checkpoint_callback def _snake_case ( lowerCamelCase__ : Optional[int] , lowerCamelCase__ : Dict ) -> List[Any]: return EarlyStopping( monitor=F"""val_{metric}""" , mode="min" if "loss" in metric else "max" , patience=lowerCamelCase__ , verbose=lowerCamelCase__ , ) class lowercase__ ( pl.Callback ): def UpperCAmelCase__ ( self : Tuple , snake_case__ : Optional[int] , snake_case__ : Union[str, Any] ): lowerCamelCase_ : Optional[int] ={F"""lr_group_{i}""": param["lr"] for i, param in enumerate(pl_module.trainer.optimizers[0].param_groups )} pl_module.logger.log_metrics(snake_case__ ) @rank_zero_only def UpperCAmelCase__ ( self : int , snake_case__ : pl.Trainer , snake_case__ : pl.LightningModule , snake_case__ : str , snake_case__ : List[str]=True ): logger.info(F"""***** {type_path} results at step {trainer.global_step:05d} *****""" ) lowerCamelCase_ : Optional[int] =trainer.callback_metrics trainer.logger.log_metrics({k: v for k, v in metrics.items() if k not in ["log", "progress_bar", "preds"]} ) # Log results lowerCamelCase_ : Dict =Path(pl_module.hparams.output_dir ) if type_path == "test": lowerCamelCase_ : Tuple =od / "test_results.txt" lowerCamelCase_ : Tuple =od / "test_generations.txt" else: # this never gets hit. I prefer not to save intermediate generations, and results are in metrics.json # If people want this it will be easy enough to add back. lowerCamelCase_ : Dict =od / F"""{type_path}_results/{trainer.global_step:05d}.txt""" lowerCamelCase_ : List[str] =od / F"""{type_path}_generations/{trainer.global_step:05d}.txt""" results_file.parent.mkdir(exist_ok=snake_case__ ) generations_file.parent.mkdir(exist_ok=snake_case__ ) with open(snake_case__ , "a+" ) as writer: for key in sorted(snake_case__ ): if key in ["log", "progress_bar", "preds"]: continue lowerCamelCase_ : Any =metrics[key] if isinstance(snake_case__ , torch.Tensor ): lowerCamelCase_ : Tuple =val.item() lowerCamelCase_ : List[Any] =F"""{key}: {val:.6f}\n""" writer.write(snake_case__ ) if not save_generations: return if "preds" in metrics: lowerCamelCase_ : List[Any] ="\n".join(metrics["preds"] ) generations_file.open("w+" ).write(snake_case__ ) @rank_zero_only def UpperCAmelCase__ ( self : Tuple , snake_case__ : List[Any] , snake_case__ : Optional[int] ): try: lowerCamelCase_ : Optional[Any] =pl_module.model.model.num_parameters() except AttributeError: lowerCamelCase_ : Union[str, Any] =pl_module.model.num_parameters() lowerCamelCase_ : List[str] =count_trainable_parameters(snake_case__ ) # mp stands for million parameters trainer.logger.log_metrics({"n_params": npars, "mp": npars / 1E6, "grad_mp": n_trainable_pars / 1E6} ) @rank_zero_only def UpperCAmelCase__ ( self : List[str] , snake_case__ : pl.Trainer , snake_case__ : pl.LightningModule ): save_json(pl_module.metrics , pl_module.metrics_save_path ) return self._write_logs(snake_case__ , snake_case__ , "test" ) @rank_zero_only def UpperCAmelCase__ ( self : Optional[Any] , snake_case__ : pl.Trainer , snake_case__ : List[str] ): save_json(pl_module.metrics , pl_module.metrics_save_path ) # Uncommenting this will save val generations # return self._write_logs(trainer, pl_module, "valid")
350
"""simple docstring""" from __future__ import annotations from collections import namedtuple def _snake_case ( lowerCamelCase__ : float , lowerCamelCase__ : float , lowerCamelCase__ : float ) -> tuple: lowerCamelCase_ : Optional[Any] =namedtuple("result" , "name value" ) if (voltage, current, power).count(0 ) != 1: raise ValueError("Only one argument must be 0" ) elif power < 0: raise ValueError( "Power cannot be negative in any electrical/electronics system" ) elif voltage == 0: return result("voltage" , power / current ) elif current == 0: return result("current" , power / voltage ) elif power == 0: return result("power" , float(round(abs(voltage * current ) , 2 ) ) ) else: raise ValueError("Exactly one argument must be 0" ) if __name__ == "__main__": import doctest doctest.testmod()
209
0
'''simple docstring''' # DISCLAIMER: This file is strongly influenced by https://github.com/yang-song/score_sde_pytorch import math from typing import Union import torch from ..configuration_utils import ConfigMixin, register_to_config from ..utils import randn_tensor from .scheduling_utils import SchedulerMixin class a ( _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ): _lowerCAmelCase = 1 @register_to_config def __init__( self , __magic_name__=20_00 , __magic_name__=0.1 , __magic_name__=20 , __magic_name__=1e-3 ) -> int: _a = None _a = None _a = None def __UpperCAmelCase ( self , __magic_name__ , __magic_name__ = None ) -> Union[str, Any]: _a = torch.linspace(1 , self.config.sampling_eps , __magic_name__ , device=__magic_name__ ) def __UpperCAmelCase ( self , __magic_name__ , __magic_name__ , __magic_name__ , __magic_name__=None ) -> Optional[Any]: if self.timesteps is None: raise ValueError( '`self.timesteps` is not set, you need to run \'set_timesteps\' after creating the scheduler' ) # TODO(Patrick) better comments + non-PyTorch # postprocess model score _a = ( -0.2_5 * t**2 * (self.config.beta_max - self.config.beta_min) - 0.5 * t * self.config.beta_min ) _a = torch.sqrt(1.0 - torch.exp(2.0 * log_mean_coeff ) ) _a = std.flatten() while len(std.shape ) < len(score.shape ): _a = std.unsqueeze(-1 ) _a = -score / std # compute _a = -1.0 / len(self.timesteps ) _a = self.config.beta_min + t * (self.config.beta_max - self.config.beta_min) _a = beta_t.flatten() while len(beta_t.shape ) < len(x.shape ): _a = beta_t.unsqueeze(-1 ) _a = -0.5 * beta_t * x _a = torch.sqrt(__magic_name__ ) _a = drift - diffusion**2 * score _a = x + drift * dt # add noise _a = randn_tensor(x.shape , layout=x.layout , generator=__magic_name__ , device=x.device , dtype=x.dtype ) _a = x_mean + diffusion * math.sqrt(-dt ) * noise return x, x_mean def __len__( self ) -> Dict: return self.config.num_train_timesteps
168
'''simple docstring''' from collections import OrderedDict from typing import TYPE_CHECKING, Any, Mapping, Optional from packaging import version from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...onnx.utils import compute_effective_axis_dimension from ...utils import logging if TYPE_CHECKING: from ...processing_utils import ProcessorMixin from ...utils import TensorType a_ : str = logging.get_logger(__name__) a_ : Tuple = { "microsoft/layoutlmv3-base": "https://huggingface.co/microsoft/layoutlmv3-base/resolve/main/config.json", } class a ( _SCREAMING_SNAKE_CASE ): _lowerCAmelCase = """layoutlmv3""" def __init__( self , __magic_name__=5_02_65 , __magic_name__=7_68 , __magic_name__=12 , __magic_name__=12 , __magic_name__=30_72 , __magic_name__="gelu" , __magic_name__=0.1 , __magic_name__=0.1 , __magic_name__=5_12 , __magic_name__=2 , __magic_name__=0.0_2 , __magic_name__=1e-5 , __magic_name__=1 , __magic_name__=0 , __magic_name__=2 , __magic_name__=10_24 , __magic_name__=1_28 , __magic_name__=1_28 , __magic_name__=True , __magic_name__=32 , __magic_name__=1_28 , __magic_name__=64 , __magic_name__=2_56 , __magic_name__=True , __magic_name__=True , __magic_name__=True , __magic_name__=2_24 , __magic_name__=3 , __magic_name__=16 , __magic_name__=None , **__magic_name__ , ) -> Dict: super().__init__( vocab_size=__magic_name__ , hidden_size=__magic_name__ , num_hidden_layers=__magic_name__ , num_attention_heads=__magic_name__ , intermediate_size=__magic_name__ , hidden_act=__magic_name__ , hidden_dropout_prob=__magic_name__ , attention_probs_dropout_prob=__magic_name__ , max_position_embeddings=__magic_name__ , type_vocab_size=__magic_name__ , initializer_range=__magic_name__ , layer_norm_eps=__magic_name__ , pad_token_id=__magic_name__ , bos_token_id=__magic_name__ , eos_token_id=__magic_name__ , **__magic_name__ , ) _a = max_ad_position_embeddings _a = coordinate_size _a = shape_size _a = has_relative_attention_bias _a = rel_pos_bins _a = max_rel_pos _a = has_spatial_attention_bias _a = rel_ad_pos_bins _a = max_rel_ad_pos _a = text_embed _a = visual_embed _a = input_size _a = num_channels _a = patch_size _a = classifier_dropout class a ( _SCREAMING_SNAKE_CASE ): _lowerCAmelCase = version.parse("""1.12""" ) @property def __UpperCAmelCase ( self ) -> Mapping[str, Mapping[int, str]]: # The order of inputs is different for question answering and sequence classification if self.task in ["question-answering", "sequence-classification"]: return OrderedDict( [ ('input_ids', {0: 'batch', 1: 'sequence'}), ('attention_mask', {0: 'batch', 1: 'sequence'}), ('bbox', {0: 'batch', 1: 'sequence'}), ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}), ] ) else: return OrderedDict( [ ('input_ids', {0: 'batch', 1: 'sequence'}), ('bbox', {0: 'batch', 1: 'sequence'}), ('attention_mask', {0: 'batch', 1: 'sequence'}), ('pixel_values', {0: 'batch', 1: 'num_channels'}), ] ) @property def __UpperCAmelCase ( self ) -> float: return 1e-5 @property def __UpperCAmelCase ( self ) -> int: return 12 def __UpperCAmelCase ( self , __magic_name__ , __magic_name__ = -1 , __magic_name__ = -1 , __magic_name__ = False , __magic_name__ = None , __magic_name__ = 3 , __magic_name__ = 40 , __magic_name__ = 40 , ) -> Mapping[str, Any]: setattr(processor.image_processor , 'apply_ocr' , __magic_name__ ) # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX _a = compute_effective_axis_dimension( __magic_name__ , fixed_dimension=OnnxConfig.default_fixed_batch , num_token_to_add=0 ) # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX _a = processor.tokenizer.num_special_tokens_to_add(__magic_name__ ) _a = compute_effective_axis_dimension( __magic_name__ , fixed_dimension=OnnxConfig.default_fixed_sequence , num_token_to_add=__magic_name__ ) # Generate dummy inputs according to compute batch and sequence _a = [[' '.join([processor.tokenizer.unk_token] ) * seq_length]] * batch_size # Generate dummy bounding boxes _a = [[[48, 84, 73, 1_28]]] * batch_size # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX # batch_size = compute_effective_axis_dimension(batch_size, fixed_dimension=OnnxConfig.default_fixed_batch) _a = self._generate_dummy_images(__magic_name__ , __magic_name__ , __magic_name__ , __magic_name__ ) _a = dict( processor( __magic_name__ , text=__magic_name__ , boxes=__magic_name__ , return_tensors=__magic_name__ , ) ) return inputs
168
1
"""simple docstring""" print((lambda quine: quine % quine)('''print((lambda quine: quine %% quine)(%r))'''))
364
"""simple docstring""" from dataclasses import dataclass from typing import Dict, Optional, Union import torch import torch.nn.functional as F from torch import nn from ..configuration_utils import ConfigMixin, register_to_config from ..utils import BaseOutput from .attention import BasicTransformerBlock from .attention_processor import AttentionProcessor, AttnProcessor from .embeddings import TimestepEmbedding, Timesteps from .modeling_utils import ModelMixin @dataclass class _lowercase ( __a ): """simple docstring""" lowercase__ = 42 class _lowercase ( __a , __a ): """simple docstring""" @register_to_config def __init__( self : List[Any] , UpperCamelCase__ : int = 32 , UpperCamelCase__ : int = 64 , UpperCamelCase__ : int = 20 , UpperCamelCase__ : int = 768 , UpperCamelCase__ : str=77 , UpperCamelCase__ : Dict=4 , UpperCamelCase__ : float = 0.0 , UpperCamelCase__ : str = "silu" , UpperCamelCase__ : Optional[str] = None , UpperCamelCase__ : Optional[str] = None , UpperCamelCase__ : Optional[str] = "linear" , UpperCamelCase__ : Optional[str] = "prd" , UpperCamelCase__ : Optional[int] = None , UpperCamelCase__ : Optional[int] = None , UpperCamelCase__ : Optional[int] = None , ) -> Any: '''simple docstring''' super().__init__() __UpperCamelCase =num_attention_heads __UpperCamelCase =attention_head_dim __UpperCamelCase =num_attention_heads * attention_head_dim __UpperCamelCase =additional_embeddings __UpperCamelCase =time_embed_dim or inner_dim __UpperCamelCase =embedding_proj_dim or embedding_dim __UpperCamelCase =clip_embed_dim or embedding_dim __UpperCamelCase =Timesteps(UpperCamelCase__ , UpperCamelCase__ , 0 ) __UpperCamelCase =TimestepEmbedding(UpperCamelCase__ , UpperCamelCase__ , out_dim=UpperCamelCase__ , act_fn=UpperCamelCase__ ) __UpperCamelCase =nn.Linear(UpperCamelCase__ , UpperCamelCase__ ) if embedding_proj_norm_type is None: __UpperCamelCase =None elif embedding_proj_norm_type == "layer": __UpperCamelCase =nn.LayerNorm(UpperCamelCase__ ) else: raise ValueError(f"""unsupported embedding_proj_norm_type: {embedding_proj_norm_type}""" ) __UpperCamelCase =nn.Linear(UpperCamelCase__ , UpperCamelCase__ ) if encoder_hid_proj_type is None: __UpperCamelCase =None elif encoder_hid_proj_type == "linear": __UpperCamelCase =nn.Linear(UpperCamelCase__ , UpperCamelCase__ ) else: raise ValueError(f"""unsupported encoder_hid_proj_type: {encoder_hid_proj_type}""" ) __UpperCamelCase =nn.Parameter(torch.zeros(1 , num_embeddings + additional_embeddings , UpperCamelCase__ ) ) if added_emb_type == "prd": __UpperCamelCase =nn.Parameter(torch.zeros(1 , 1 , UpperCamelCase__ ) ) elif added_emb_type is None: __UpperCamelCase =None else: raise ValueError( f"""`added_emb_type`: {added_emb_type} is not supported. Make sure to choose one of `'prd'` or `None`.""" ) __UpperCamelCase =nn.ModuleList( [ BasicTransformerBlock( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , dropout=UpperCamelCase__ , activation_fn='''gelu''' , attention_bias=UpperCamelCase__ , ) for d in range(UpperCamelCase__ ) ] ) if norm_in_type == "layer": __UpperCamelCase =nn.LayerNorm(UpperCamelCase__ ) elif norm_in_type is None: __UpperCamelCase =None else: raise ValueError(f"""Unsupported norm_in_type: {norm_in_type}.""" ) __UpperCamelCase =nn.LayerNorm(UpperCamelCase__ ) __UpperCamelCase =nn.Linear(UpperCamelCase__ , UpperCamelCase__ ) __UpperCamelCase =torch.full( [num_embeddings + additional_embeddings, num_embeddings + additional_embeddings] , -1_00_00.0 ) causal_attention_mask.triu_(1 ) __UpperCamelCase =causal_attention_mask[None, ...] self.register_buffer('''causal_attention_mask''' , UpperCamelCase__ , persistent=UpperCamelCase__ ) __UpperCamelCase =nn.Parameter(torch.zeros(1 , UpperCamelCase__ ) ) __UpperCamelCase =nn.Parameter(torch.zeros(1 , UpperCamelCase__ ) ) @property # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors def UpperCAmelCase_ ( self : Any ) -> Dict[str, AttentionProcessor]: '''simple docstring''' __UpperCamelCase ={} def fn_recursive_add_processors(UpperCamelCase__ : str , UpperCamelCase__ : torch.nn.Module , UpperCamelCase__ : Dict[str, AttentionProcessor] ): if hasattr(UpperCamelCase__ , '''set_processor''' ): __UpperCamelCase =module.processor for sub_name, child in module.named_children(): fn_recursive_add_processors(f"""{name}.{sub_name}""" , UpperCamelCase__ , UpperCamelCase__ ) return processors for name, module in self.named_children(): fn_recursive_add_processors(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) return processors def UpperCAmelCase_ ( self : int , UpperCamelCase__ : Union[AttentionProcessor, Dict[str, AttentionProcessor]] ) -> Optional[int]: '''simple docstring''' __UpperCamelCase =len(self.attn_processors.keys() ) if isinstance(UpperCamelCase__ , UpperCamelCase__ ) and len(UpperCamelCase__ ) != count: raise ValueError( f"""A dict of processors was passed, but the number of processors {len(UpperCamelCase__ )} does not match the""" f""" number of attention layers: {count}. Please make sure to pass {count} processor classes.""" ) def fn_recursive_attn_processor(UpperCamelCase__ : str , UpperCamelCase__ : torch.nn.Module , UpperCamelCase__ : int ): if hasattr(UpperCamelCase__ , '''set_processor''' ): if not isinstance(UpperCamelCase__ , UpperCamelCase__ ): module.set_processor(UpperCamelCase__ ) else: module.set_processor(processor.pop(f"""{name}.processor""" ) ) for sub_name, child in module.named_children(): fn_recursive_attn_processor(f"""{name}.{sub_name}""" , UpperCamelCase__ , UpperCamelCase__ ) for name, module in self.named_children(): fn_recursive_attn_processor(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) def UpperCAmelCase_ ( self : Dict ) -> Tuple: '''simple docstring''' self.set_attn_processor(AttnProcessor() ) def UpperCAmelCase_ ( self : List[Any] , UpperCamelCase__ : Optional[Any] , UpperCamelCase__ : Union[torch.Tensor, float, int] , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : Optional[torch.FloatTensor] = None , UpperCamelCase__ : Optional[torch.BoolTensor] = None , UpperCamelCase__ : bool = True , ) -> Tuple: '''simple docstring''' __UpperCamelCase =hidden_states.shape[0] __UpperCamelCase =timestep if not torch.is_tensor(UpperCamelCase__ ): __UpperCamelCase =torch.tensor([timesteps] , dtype=torch.long , device=hidden_states.device ) elif torch.is_tensor(UpperCamelCase__ ) and len(timesteps.shape ) == 0: __UpperCamelCase =timesteps[None].to(hidden_states.device ) # broadcast to batch dimension in a way that's compatible with ONNX/Core ML __UpperCamelCase =timesteps * torch.ones(UpperCamelCase__ , dtype=timesteps.dtype , device=timesteps.device ) __UpperCamelCase =self.time_proj(UpperCamelCase__ ) # timesteps does not contain any weights and will always return f32 tensors # but time_embedding might be fp16, so we need to cast here. __UpperCamelCase =timesteps_projected.to(dtype=self.dtype ) __UpperCamelCase =self.time_embedding(UpperCamelCase__ ) if self.embedding_proj_norm is not None: __UpperCamelCase =self.embedding_proj_norm(UpperCamelCase__ ) __UpperCamelCase =self.embedding_proj(UpperCamelCase__ ) if self.encoder_hidden_states_proj is not None and encoder_hidden_states is not None: __UpperCamelCase =self.encoder_hidden_states_proj(UpperCamelCase__ ) elif self.encoder_hidden_states_proj is not None and encoder_hidden_states is None: raise ValueError('''`encoder_hidden_states_proj` requires `encoder_hidden_states` to be set''' ) __UpperCamelCase =self.proj_in(UpperCamelCase__ ) __UpperCamelCase =self.positional_embedding.to(hidden_states.dtype ) __UpperCamelCase =[] __UpperCamelCase =0 if encoder_hidden_states is not None: additional_embeds.append(UpperCamelCase__ ) additional_embeddings_len += encoder_hidden_states.shape[1] if len(proj_embeddings.shape ) == 2: __UpperCamelCase =proj_embeddings[:, None, :] if len(hidden_states.shape ) == 2: __UpperCamelCase =hidden_states[:, None, :] __UpperCamelCase =additional_embeds + [ proj_embeddings, time_embeddings[:, None, :], hidden_states, ] if self.prd_embedding is not None: __UpperCamelCase =self.prd_embedding.to(hidden_states.dtype ).expand(UpperCamelCase__ , -1 , -1 ) additional_embeds.append(UpperCamelCase__ ) __UpperCamelCase =torch.cat( UpperCamelCase__ , dim=1 , ) # Allow positional_embedding to not include the `addtional_embeddings` and instead pad it with zeros for these additional tokens __UpperCamelCase =additional_embeddings_len + proj_embeddings.shape[1] + 1 if positional_embeddings.shape[1] < hidden_states.shape[1]: __UpperCamelCase =F.pad( UpperCamelCase__ , ( 0, 0, additional_embeddings_len, self.prd_embedding.shape[1] if self.prd_embedding is not None else 0, ) , value=0.0 , ) __UpperCamelCase =hidden_states + positional_embeddings if attention_mask is not None: __UpperCamelCase =(1 - attention_mask.to(hidden_states.dtype )) * -1_00_00.0 __UpperCamelCase =F.pad(UpperCamelCase__ , (0, self.additional_embeddings) , value=0.0 ) __UpperCamelCase =(attention_mask[:, None, :] + self.causal_attention_mask).to(hidden_states.dtype ) __UpperCamelCase =attention_mask.repeat_interleave(self.config.num_attention_heads , dim=0 ) if self.norm_in is not None: __UpperCamelCase =self.norm_in(UpperCamelCase__ ) for block in self.transformer_blocks: __UpperCamelCase =block(UpperCamelCase__ , attention_mask=UpperCamelCase__ ) __UpperCamelCase =self.norm_out(UpperCamelCase__ ) if self.prd_embedding is not None: __UpperCamelCase =hidden_states[:, -1] else: __UpperCamelCase =hidden_states[:, additional_embeddings_len:] __UpperCamelCase =self.proj_to_clip_embeddings(UpperCamelCase__ ) if not return_dict: return (predicted_image_embedding,) return PriorTransformerOutput(predicted_image_embedding=UpperCamelCase__ ) def UpperCAmelCase_ ( self : Dict , UpperCamelCase__ : int ) -> List[Any]: '''simple docstring''' __UpperCamelCase =(prior_latents * self.clip_std) + self.clip_mean return prior_latents
85
0
'''simple docstring''' from __future__ import annotations from fractions import Fraction def a__ ( lowerCAmelCase__ , lowerCAmelCase__ ) -> bool: return ( num != den and num % 10 == den // 10 and (num // 10) / (den % 10) == num / den ) def a__ ( lowerCAmelCase__ ) -> list[str]: UpperCAmelCase__ : List[str] = [] UpperCAmelCase__ : List[Any] = 11 UpperCAmelCase__ : List[Any] = int('''1''' + '''0''' * digit_len ) for num in range(lowercase__ , lowercase__ ): while den <= 99: if (num != den) and (num % 10 == den // 10) and (den % 10 != 0): if is_digit_cancelling(lowercase__ , lowercase__ ): solutions.append(F"""{num}/{den}""" ) den += 1 num += 1 UpperCAmelCase__ : Optional[Any] = 10 return solutions def a__ ( lowerCAmelCase__ = 2 ) -> int: UpperCAmelCase__ : List[Any] = 1.0 for fraction in fraction_list(lowercase__ ): UpperCAmelCase__ : Any = Fraction(lowercase__ ) result *= frac.denominator / frac.numerator return int(lowercase__ ) if __name__ == "__main__": print(solution())
181
import os import tempfile import unittest from transformers import DistilBertConfig, is_torch_available from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST, DistilBertForMaskedLM, DistilBertForMultipleChoice, DistilBertForQuestionAnswering, DistilBertForSequenceClassification, DistilBertForTokenClassification, DistilBertModel, ) class A ( A_ ): def __init__(self , lowerCAmelCase , lowerCAmelCase=1_3 , lowerCAmelCase=7 , lowerCAmelCase=True , lowerCAmelCase=True , lowerCAmelCase=False , lowerCAmelCase=True , lowerCAmelCase=9_9 , lowerCAmelCase=3_2 , lowerCAmelCase=5 , lowerCAmelCase=4 , lowerCAmelCase=3_7 , lowerCAmelCase="gelu" , lowerCAmelCase=0.1 , lowerCAmelCase=0.1 , lowerCAmelCase=5_1_2 , lowerCAmelCase=1_6 , lowerCAmelCase=2 , lowerCAmelCase=0.02 , lowerCAmelCase=3 , lowerCAmelCase=4 , lowerCAmelCase=None , ): __lowercase= parent __lowercase= batch_size __lowercase= seq_length __lowercase= is_training __lowercase= use_input_mask __lowercase= use_token_type_ids __lowercase= use_labels __lowercase= vocab_size __lowercase= hidden_size __lowercase= num_hidden_layers __lowercase= num_attention_heads __lowercase= intermediate_size __lowercase= hidden_act __lowercase= hidden_dropout_prob __lowercase= attention_probs_dropout_prob __lowercase= max_position_embeddings __lowercase= type_vocab_size __lowercase= type_sequence_label_size __lowercase= initializer_range __lowercase= num_labels __lowercase= num_choices __lowercase= scope def _A (self ): __lowercase= ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) __lowercase= None if self.use_input_mask: __lowercase= random_attention_mask([self.batch_size, self.seq_length] ) __lowercase= None __lowercase= None __lowercase= None if self.use_labels: __lowercase= ids_tensor([self.batch_size] , self.type_sequence_label_size ) __lowercase= ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) __lowercase= ids_tensor([self.batch_size] , self.num_choices ) __lowercase= self.get_config() return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels def _A (self ): return 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 , ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase ): __lowercase= DistilBertModel(config=lowerCAmelCase ) model.to(lowerCAmelCase ) model.eval() __lowercase= model(lowerCAmelCase , lowerCAmelCase ) __lowercase= model(lowerCAmelCase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase ): __lowercase= DistilBertForMaskedLM(config=lowerCAmelCase ) model.to(lowerCAmelCase ) model.eval() __lowercase= model(lowerCAmelCase , attention_mask=lowerCAmelCase , labels=lowerCAmelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase ): __lowercase= DistilBertForQuestionAnswering(config=lowerCAmelCase ) model.to(lowerCAmelCase ) model.eval() __lowercase= model( lowerCAmelCase , attention_mask=lowerCAmelCase , start_positions=lowerCAmelCase , end_positions=lowerCAmelCase ) self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase ): __lowercase= self.num_labels __lowercase= DistilBertForSequenceClassification(lowerCAmelCase ) model.to(lowerCAmelCase ) model.eval() __lowercase= model(lowerCAmelCase , attention_mask=lowerCAmelCase , labels=lowerCAmelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase ): __lowercase= self.num_labels __lowercase= DistilBertForTokenClassification(config=lowerCAmelCase ) model.to(lowerCAmelCase ) model.eval() __lowercase= model(lowerCAmelCase , attention_mask=lowerCAmelCase , labels=lowerCAmelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase ): __lowercase= self.num_choices __lowercase= DistilBertForMultipleChoice(config=lowerCAmelCase ) model.to(lowerCAmelCase ) model.eval() __lowercase= input_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() __lowercase= input_mask.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() __lowercase= model( lowerCAmelCase , attention_mask=lowerCAmelCase , labels=lowerCAmelCase , ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) ) def _A (self ): __lowercase= self.prepare_config_and_inputs() ((__lowercase), (__lowercase), (__lowercase), (__lowercase), (__lowercase), (__lowercase))= config_and_inputs __lowercase= {'input_ids': input_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class A ( A_ , A_ , unittest.TestCase ): UpperCamelCase_ : Any =( ( DistilBertModel, DistilBertForMaskedLM, DistilBertForMultipleChoice, DistilBertForQuestionAnswering, DistilBertForSequenceClassification, DistilBertForTokenClassification, ) if is_torch_available() else None ) UpperCamelCase_ : Optional[int] =( { '''feature-extraction''': DistilBertModel, '''fill-mask''': DistilBertForMaskedLM, '''question-answering''': DistilBertForQuestionAnswering, '''text-classification''': DistilBertForSequenceClassification, '''token-classification''': DistilBertForTokenClassification, '''zero-shot''': DistilBertForSequenceClassification, } if is_torch_available() else {} ) UpperCamelCase_ : str =True UpperCamelCase_ : str =True UpperCamelCase_ : Union[str, Any] =True UpperCamelCase_ : Optional[int] =True def _A (self ): __lowercase= DistilBertModelTester(self ) __lowercase= ConfigTester(self , config_class=lowerCAmelCase , dim=3_7 ) def _A (self ): self.config_tester.run_common_tests() def _A (self ): __lowercase= self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_distilbert_model(*lowerCAmelCase ) def _A (self ): __lowercase= self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_distilbert_for_masked_lm(*lowerCAmelCase ) def _A (self ): __lowercase= self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_distilbert_for_question_answering(*lowerCAmelCase ) def _A (self ): __lowercase= self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_distilbert_for_sequence_classification(*lowerCAmelCase ) def _A (self ): __lowercase= self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_distilbert_for_token_classification(*lowerCAmelCase ) def _A (self ): __lowercase= self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_distilbert_for_multiple_choice(*lowerCAmelCase ) @slow def _A (self ): for model_name in DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: __lowercase= DistilBertModel.from_pretrained(lowerCAmelCase ) self.assertIsNotNone(lowerCAmelCase ) @slow @require_torch_gpu def _A (self ): __lowercase, __lowercase= self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: # BertForMultipleChoice behaves incorrectly in JIT environments. if model_class == DistilBertForMultipleChoice: return __lowercase= True __lowercase= model_class(config=lowerCAmelCase ) __lowercase= self._prepare_for_class(lowerCAmelCase , lowerCAmelCase ) __lowercase= torch.jit.trace( lowerCAmelCase , (inputs_dict['input_ids'].to('cpu' ), inputs_dict['attention_mask'].to('cpu' )) ) with tempfile.TemporaryDirectory() as tmp: torch.jit.save(lowerCAmelCase , os.path.join(lowerCAmelCase , 'traced_model.pt' ) ) __lowercase= torch.jit.load(os.path.join(lowerCAmelCase , 'traced_model.pt' ) , map_location=lowerCAmelCase ) loaded(inputs_dict['input_ids'].to(lowerCAmelCase ) , inputs_dict['attention_mask'].to(lowerCAmelCase ) ) @require_torch class A ( unittest.TestCase ): @slow def _A (self ): __lowercase= DistilBertModel.from_pretrained('distilbert-base-uncased' ) __lowercase= torch.tensor([[0, 3_4_5, 2_3_2, 3_2_8, 7_4_0, 1_4_0, 1_6_9_5, 6_9, 6_0_7_8, 1_5_8_8, 2]] ) __lowercase= torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] ) with torch.no_grad(): __lowercase= model(lowerCAmelCase , attention_mask=lowerCAmelCase )[0] __lowercase= torch.Size((1, 1_1, 7_6_8) ) self.assertEqual(output.shape , lowerCAmelCase ) __lowercase= torch.tensor( [[[-0.16_39, 0.32_99, 0.16_48], [-0.17_46, 0.32_89, 0.17_10], [-0.18_84, 0.33_57, 0.18_10]]] ) self.assertTrue(torch.allclose(output[:, 1:4, 1:4] , lowerCAmelCase , atol=1E-4 ) )
295
0
"""simple docstring""" import flax.linen as nn import jax import jax.numpy as jnp class _A ( nn.Module ): snake_case__ : int snake_case__ : jnp.dtype = jnp.floataa def A__ ( self ): """simple docstring""" lowercase = nn.Conv( self.out_channels , kernel_size=(3, 3) , strides=(1, 1) , padding=((1, 1), (1, 1)) , dtype=self.dtype , ) def __call__( self , __lowerCAmelCase ): """simple docstring""" lowercase , lowercase , lowercase , lowercase = hidden_states.shape lowercase = jax.image.resize( __lowerCAmelCase , shape=(batch, height * 2, width * 2, channels) , method="""nearest""" , ) lowercase = self.conv(__lowerCAmelCase ) return hidden_states class _A ( nn.Module ): snake_case__ : int snake_case__ : jnp.dtype = jnp.floataa def A__ ( self ): """simple docstring""" lowercase = nn.Conv( self.out_channels , kernel_size=(3, 3) , strides=(2, 2) , padding=((1, 1), (1, 1)) , dtype=self.dtype , ) def __call__( self , __lowerCAmelCase ): """simple docstring""" lowercase = self.conv(__lowerCAmelCase ) return hidden_states class _A ( nn.Module ): snake_case__ : int snake_case__ : int = None snake_case__ : float = 0.0 snake_case__ : bool = None snake_case__ : jnp.dtype = jnp.floataa def A__ ( self ): """simple docstring""" lowercase = self.in_channels if self.out_channels is None else self.out_channels lowercase = nn.GroupNorm(num_groups=32 , epsilon=1E-5 ) lowercase = nn.Conv( __lowerCAmelCase , kernel_size=(3, 3) , strides=(1, 1) , padding=((1, 1), (1, 1)) , dtype=self.dtype , ) lowercase = nn.Dense(__lowerCAmelCase , dtype=self.dtype ) lowercase = nn.GroupNorm(num_groups=32 , epsilon=1E-5 ) lowercase = nn.Dropout(self.dropout_prob ) lowercase = nn.Conv( __lowerCAmelCase , kernel_size=(3, 3) , strides=(1, 1) , padding=((1, 1), (1, 1)) , dtype=self.dtype , ) lowercase = self.in_channels != out_channels if self.use_nin_shortcut is None else self.use_nin_shortcut lowercase = None if use_nin_shortcut: lowercase = nn.Conv( __lowerCAmelCase , kernel_size=(1, 1) , strides=(1, 1) , padding="""VALID""" , dtype=self.dtype , ) def __call__( self , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase=True ): """simple docstring""" lowercase = hidden_states lowercase = self.norma(__lowerCAmelCase ) lowercase = nn.swish(__lowerCAmelCase ) lowercase = self.conva(__lowerCAmelCase ) lowercase = self.time_emb_proj(nn.swish(__lowerCAmelCase ) ) lowercase = jnp.expand_dims(jnp.expand_dims(__lowerCAmelCase , 1 ) , 1 ) lowercase = hidden_states + temb lowercase = self.norma(__lowerCAmelCase ) lowercase = nn.swish(__lowerCAmelCase ) lowercase = self.dropout(__lowerCAmelCase , __lowerCAmelCase ) lowercase = self.conva(__lowerCAmelCase ) if self.conv_shortcut is not None: lowercase = self.conv_shortcut(__lowerCAmelCase ) return hidden_states + residual
32
"""simple docstring""" import argparse import requests import torch from PIL import Image from transformers import CLIPProcessor, GroupViTConfig, GroupViTModel def UpperCAmelCase__ ( lowerCAmelCase__ :Union[str, Any] ) -> Dict: '''simple docstring''' if "img_encoder.pos_embed" in name: lowercase = name.replace("""img_encoder.pos_embed""" , """vision_model.embeddings.position_embeddings""" ) if "img_encoder.patch_embed.proj" in name: lowercase = name.replace("""img_encoder.patch_embed.proj""" , """vision_model.embeddings.patch_embeddings.projection""" ) if "img_encoder.patch_embed.norm" in name: lowercase = name.replace("""img_encoder.patch_embed.norm""" , """vision_model.embeddings.layernorm""" ) if "img_encoder.layers" in name: lowercase = name.replace("""img_encoder.layers""" , """vision_model.encoder.stages""" ) if "blocks" in name and "res" not in name: lowercase = name.replace("""blocks""" , """layers""" ) if "attn" in name and "pre_assign" not in name: lowercase = name.replace("""attn""" , """self_attn""" ) if "proj" in name and "self_attn" in name and "text" not in name: lowercase = name.replace("""proj""" , """out_proj""" ) if "pre_assign_attn.attn.proj" in name: lowercase = name.replace("""pre_assign_attn.attn.proj""" , """pre_assign_attn.attn.out_proj""" ) if "norm1" in name: lowercase = name.replace("""norm1""" , """layer_norm1""" ) if "norm2" in name and "pre_assign" not in name: lowercase = name.replace("""norm2""" , """layer_norm2""" ) if "img_encoder.norm" in name: lowercase = name.replace("""img_encoder.norm""" , """vision_model.layernorm""" ) # text encoder if "text_encoder.token_embedding" in name: lowercase = name.replace("""text_encoder.token_embedding""" , """text_model.embeddings.token_embedding""" ) if "text_encoder.positional_embedding" in name: lowercase = name.replace("""text_encoder.positional_embedding""" , """text_model.embeddings.position_embedding.weight""" ) if "text_encoder.transformer.resblocks." in name: lowercase = name.replace("""text_encoder.transformer.resblocks.""" , """text_model.encoder.layers.""" ) if "ln_1" in name: lowercase = name.replace("""ln_1""" , """layer_norm1""" ) if "ln_2" in name: lowercase = name.replace("""ln_2""" , """layer_norm2""" ) if "c_fc" in name: lowercase = name.replace("""c_fc""" , """fc1""" ) if "c_proj" in name: lowercase = name.replace("""c_proj""" , """fc2""" ) if "text_encoder" in name: lowercase = name.replace("""text_encoder""" , """text_model""" ) if "ln_final" in name: lowercase = name.replace("""ln_final""" , """final_layer_norm""" ) # projection layers if "img_projector.linear_hidden." in name: lowercase = name.replace("""img_projector.linear_hidden.""" , """visual_projection.""" ) if "img_projector.linear_out." in name: lowercase = name.replace("""img_projector.linear_out.""" , """visual_projection.3.""" ) if "text_projector.linear_hidden" in name: lowercase = name.replace("""text_projector.linear_hidden""" , """text_projection""" ) if "text_projector.linear_out" in name: lowercase = name.replace("""text_projector.linear_out""" , """text_projection.3""" ) return name def UpperCAmelCase__ ( lowerCAmelCase__ :List[str] , lowerCAmelCase__ :Union[str, Any] ) -> List[str]: '''simple docstring''' for key in orig_state_dict.copy().keys(): lowercase = orig_state_dict.pop(lowerCAmelCase__ ) if "qkv" in key: # weights and biases of the key, value and query projections of vision encoder's attention layers require special treatment: # we need to split them up into separate matrices/vectors lowercase = key.split(""".""" ) lowercase , lowercase = int(key_split[2] ), int(key_split[4] ) lowercase = config.vision_config.hidden_size if "weight" in key: lowercase = val[:dim, :] lowercase = val[dim : dim * 2, :] lowercase = val[-dim:, :] else: lowercase = val[:dim] lowercase = val[dim : dim * 2] lowercase = val[-dim:] elif "in_proj" in key: # weights and biases of the key, value and query projections of text encoder's attention layers require special treatment: # we need to split them up into separate matrices/vectors lowercase = key.split(""".""" ) lowercase = int(key_split[3] ) lowercase = config.text_config.hidden_size if "weight" in key: lowercase = val[:dim, :] lowercase = val[ dim : dim * 2, : ] lowercase = val[-dim:, :] else: lowercase = val[:dim] lowercase = val[dim : dim * 2] lowercase = val[-dim:] else: lowercase = rename_key(lowerCAmelCase__ ) # squeeze if necessary if ( "text_projection.0" in new_name or "text_projection.3" in new_name or "visual_projection.0" in new_name or "visual_projection.3" in new_name ): lowercase = val.squeeze_() else: lowercase = val return orig_state_dict def UpperCAmelCase__ ( ) -> Union[str, Any]: '''simple docstring''' lowercase = """http://images.cocodataset.org/val2017/000000039769.jpg""" lowercase = Image.open(requests.get(lowerCAmelCase__ , stream=lowerCAmelCase__ ).raw ) return im @torch.no_grad() def UpperCAmelCase__ ( lowerCAmelCase__ :Union[str, Any] , lowerCAmelCase__ :List[str] , lowerCAmelCase__ :int="groupvit-gcc-yfcc" , lowerCAmelCase__ :List[Any]=False ) -> str: '''simple docstring''' lowercase = GroupViTConfig() lowercase = GroupViTModel(lowerCAmelCase__ ).eval() lowercase = torch.load(lowerCAmelCase__ , map_location="""cpu""" )["""model"""] lowercase = convert_state_dict(lowerCAmelCase__ , lowerCAmelCase__ ) lowercase , lowercase = model.load_state_dict(lowerCAmelCase__ , strict=lowerCAmelCase__ ) assert missing_keys == ["text_model.embeddings.position_ids"] assert (unexpected_keys == ["multi_label_logit_scale"]) or (len(lowerCAmelCase__ ) == 0) # verify result lowercase = CLIPProcessor.from_pretrained("""openai/clip-vit-base-patch32""" ) lowercase = prepare_img() lowercase = processor(text=["""a photo of a cat""", """a photo of a dog"""] , images=lowerCAmelCase__ , padding=lowerCAmelCase__ , return_tensors="""pt""" ) with torch.no_grad(): lowercase = model(**lowerCAmelCase__ ) if model_name == "groupvit-gcc-yfcc": lowercase = torch.tensor([[13.3_523, 6.3_629]] ) elif model_name == "groupvit-gcc-redcaps": lowercase = torch.tensor([[16.1_873, 8.6_230]] ) else: raise ValueError(f'Model name {model_name} not supported.' ) assert torch.allclose(outputs.logits_per_image , lowerCAmelCase__ , atol=1e-3 ) processor.save_pretrained(lowerCAmelCase__ ) model.save_pretrained(lowerCAmelCase__ ) print("""Successfully saved processor and model to""" , lowerCAmelCase__ ) if push_to_hub: print("""Pushing to the hub...""" ) processor.push_to_hub(lowerCAmelCase__ , organization="""nielsr""" ) model.push_to_hub(lowerCAmelCase__ , organization="""nielsr""" ) if __name__ == "__main__": __lowerCAmelCase : str =argparse.ArgumentParser() parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to dump the processor and PyTorch model.""" ) parser.add_argument("""--checkpoint_path""", default=None, type=str, help="""Path to GroupViT checkpoint""") parser.add_argument( """--model_name""", default="""groupvit-gccy-fcc""", type=str, help="""Name of the model. Expecting either 'groupvit-gcc-yfcc' or 'groupvit-gcc-redcaps'""", ) parser.add_argument( """--push_to_hub""", action="""store_true""", help="""Whether or not to push the converted model and processor to the 🤗 hub using the provided `model_name`.""", ) __lowerCAmelCase : int =parser.parse_args() convert_groupvit_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub)
32
1
'''simple docstring''' import os from shutil import copyfile from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging A__: List[str] = logging.get_logger(__name__) A__: int = {'''vocab_file''': '''spm_char.model'''} A__: Tuple = { '''vocab_file''': { '''microsoft/speecht5_asr''': '''https://huggingface.co/microsoft/speecht5_asr/resolve/main/spm_char.model''', '''microsoft/speecht5_tts''': '''https://huggingface.co/microsoft/speecht5_tts/resolve/main/spm_char.model''', '''microsoft/speecht5_vc''': '''https://huggingface.co/microsoft/speecht5_vc/resolve/main/spm_char.model''', } } A__: Dict = { '''microsoft/speecht5_asr''': 1024, '''microsoft/speecht5_tts''': 1024, '''microsoft/speecht5_vc''': 1024, } class A__ ( UpperCAmelCase__ ): __UpperCamelCase : Union[str, Any] = VOCAB_FILES_NAMES __UpperCamelCase : Any = PRETRAINED_VOCAB_FILES_MAP __UpperCamelCase : Tuple = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES __UpperCamelCase : int = ["input_ids", "attention_mask"] def __init__( self :Any , SCREAMING_SNAKE_CASE :Optional[Any] , SCREAMING_SNAKE_CASE :List[str]="<s>" , SCREAMING_SNAKE_CASE :Optional[int]="</s>" , SCREAMING_SNAKE_CASE :Tuple="<unk>" , SCREAMING_SNAKE_CASE :int="<pad>" , SCREAMING_SNAKE_CASE :Optional[Any] = None , **SCREAMING_SNAKE_CASE :int , ) -> Any: '''simple docstring''' _a : List[str] ={} if sp_model_kwargs is None else sp_model_kwargs super().__init__( bos_token=SCREAMING_SNAKE_CASE , eos_token=SCREAMING_SNAKE_CASE , unk_token=SCREAMING_SNAKE_CASE , pad_token=SCREAMING_SNAKE_CASE , sp_model_kwargs=self.sp_model_kwargs , **SCREAMING_SNAKE_CASE , ) _a : str =vocab_file _a : Union[str, Any] =spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(SCREAMING_SNAKE_CASE ) @property def __UpperCAmelCase ( self :Optional[Any] ) -> int: '''simple docstring''' return self.sp_model.get_piece_size() def __UpperCAmelCase ( self :List[Any] ) -> Any: '''simple docstring''' _a : Optional[int] ={self.convert_ids_to_tokens(SCREAMING_SNAKE_CASE ): i for i in range(self.vocab_size )} vocab.update(self.added_tokens_encoder ) return vocab def __getstate__( self :int ) -> int: '''simple docstring''' _a : Optional[Any] =self.__dict__.copy() _a : Tuple =None return state def __setstate__( self :Any , SCREAMING_SNAKE_CASE :Tuple ) -> Tuple: '''simple docstring''' _a : int =d # for backward compatibility if not hasattr(self , """sp_model_kwargs""" ): _a : Tuple ={} _a : List[str] =spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(self.vocab_file ) def __UpperCAmelCase ( self :Tuple , SCREAMING_SNAKE_CASE :Dict ) -> Union[str, Any]: '''simple docstring''' return self.sp_model.encode(SCREAMING_SNAKE_CASE , out_type=SCREAMING_SNAKE_CASE ) def __UpperCAmelCase ( self :Any , SCREAMING_SNAKE_CASE :Dict ) -> List[str]: '''simple docstring''' return self.sp_model.piece_to_id(SCREAMING_SNAKE_CASE ) def __UpperCAmelCase ( self :Tuple , SCREAMING_SNAKE_CASE :Dict ) -> str: '''simple docstring''' _a : Dict =self.sp_model.IdToPiece(SCREAMING_SNAKE_CASE ) return token def __UpperCAmelCase ( self :int , SCREAMING_SNAKE_CASE :Any ) -> Union[str, Any]: '''simple docstring''' _a : Dict =[] _a : List[str] ='' for token in tokens: # make sure that special tokens are not decoded using sentencepiece model if token in self.all_special_tokens: out_string += self.sp_model.decode(SCREAMING_SNAKE_CASE ) + token _a : List[Any] =[] else: current_sub_tokens.append(SCREAMING_SNAKE_CASE ) out_string += self.sp_model.decode(SCREAMING_SNAKE_CASE ) return out_string.strip() def __UpperCAmelCase ( self :Optional[Any] , SCREAMING_SNAKE_CASE :Dict , SCREAMING_SNAKE_CASE :List[str]=None ) -> int: '''simple docstring''' if token_ids_a is None: return token_ids_a + [self.eos_token_id] # We don't expect to process pairs, but leave the pair logic for API consistency return token_ids_a + token_ids_a + [self.eos_token_id] def __UpperCAmelCase ( self :List[str] , SCREAMING_SNAKE_CASE :Union[str, Any] , SCREAMING_SNAKE_CASE :str = None , SCREAMING_SNAKE_CASE :Union[str, Any] = False ) -> Optional[Any]: '''simple docstring''' if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=SCREAMING_SNAKE_CASE , token_ids_a=SCREAMING_SNAKE_CASE , already_has_special_tokens=SCREAMING_SNAKE_CASE ) _a : Optional[int] =[1] if token_ids_a is None: return ([0] * len(SCREAMING_SNAKE_CASE )) + suffix_ones return ([0] * len(SCREAMING_SNAKE_CASE )) + ([0] * len(SCREAMING_SNAKE_CASE )) + suffix_ones def __UpperCAmelCase ( self :str , SCREAMING_SNAKE_CASE :List[Any] , SCREAMING_SNAKE_CASE :Union[str, Any] = None ) -> Dict: '''simple docstring''' if not os.path.isdir(SCREAMING_SNAKE_CASE ): logger.error(f"Vocabulary path ({save_directory}) should be a directory" ) return _a : Tuple =os.path.join( SCREAMING_SNAKE_CASE , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(SCREAMING_SNAKE_CASE ) and os.path.isfile(self.vocab_file ): copyfile(self.vocab_file , SCREAMING_SNAKE_CASE ) elif not os.path.isfile(self.vocab_file ): with open(SCREAMING_SNAKE_CASE , """wb""" ) as fi: _a : str =self.sp_model.serialized_model_proto() fi.write(SCREAMING_SNAKE_CASE ) return (out_vocab_file,)
276
"""simple docstring""" from __future__ import annotations import copy import tempfile import unittest from transformers import CONFIG_MAPPING, AutoConfig, BertConfig, GPTaConfig, TaConfig, TapasConfig, is_tf_available from transformers.testing_utils import ( DUMMY_UNKNOWN_IDENTIFIER, SMALL_MODEL_IDENTIFIER, RequestCounter, require_tensorflow_probability, require_tf, slow, ) from ..bert.test_modeling_bert import BertModelTester if is_tf_available(): from transformers import ( TFAutoModel, TFAutoModelForCausalLM, TFAutoModelForMaskedLM, TFAutoModelForPreTraining, TFAutoModelForQuestionAnswering, TFAutoModelForSeqaSeqLM, TFAutoModelForSequenceClassification, TFAutoModelForTableQuestionAnswering, TFAutoModelForTokenClassification, TFAutoModelWithLMHead, TFBertForMaskedLM, TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification, TFBertModel, TFFunnelBaseModel, TFFunnelModel, TFGPTaLMHeadModel, TFRobertaForMaskedLM, TFTaForConditionalGeneration, TFTapasForQuestionAnswering, ) from transformers.models.auto.modeling_tf_auto import ( TF_MODEL_FOR_CAUSAL_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_PRETRAINING_MAPPING, TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING, TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING, TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING, TF_MODEL_MAPPING, ) from transformers.models.bert.modeling_tf_bert import TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST from transformers.models.gpta.modeling_tf_gpta import TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST from transformers.models.ta.modeling_tf_ta import TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST from transformers.models.tapas.modeling_tf_tapas import TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST class lowerCAmelCase__ ( lowercase ): '''simple docstring''' lowerCamelCase__ = """new-model""" if is_tf_available(): class lowerCAmelCase__ ( lowercase ): '''simple docstring''' lowerCamelCase__ = NewModelConfig @require_tf class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' @slow def A_ ( self ): _lowerCamelCase : List[str] = 'bert-base-cased' _lowerCamelCase : Union[str, Any] = AutoConfig.from_pretrained(lowercase ) self.assertIsNotNone(lowercase ) self.assertIsInstance(lowercase , lowercase ) _lowerCamelCase : Union[str, Any] = TFAutoModel.from_pretrained(lowercase ) self.assertIsNotNone(lowercase ) self.assertIsInstance(lowercase , lowercase ) @slow def A_ ( self ): _lowerCamelCase : List[str] = 'bert-base-cased' _lowerCamelCase : int = AutoConfig.from_pretrained(lowercase ) self.assertIsNotNone(lowercase ) self.assertIsInstance(lowercase , lowercase ) _lowerCamelCase : int = TFAutoModelForPreTraining.from_pretrained(lowercase ) self.assertIsNotNone(lowercase ) self.assertIsInstance(lowercase , lowercase ) @slow def A_ ( self ): for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _lowerCamelCase : Dict = AutoConfig.from_pretrained(lowercase ) self.assertIsNotNone(lowercase ) self.assertIsInstance(lowercase , lowercase ) _lowerCamelCase : int = TFAutoModelForCausalLM.from_pretrained(lowercase ) _lowerCamelCase, _lowerCamelCase : str = TFAutoModelForCausalLM.from_pretrained(lowercase , output_loading_info=lowercase ) self.assertIsNotNone(lowercase ) self.assertIsInstance(lowercase , lowercase ) @slow def A_ ( self ): for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _lowerCamelCase : List[Any] = AutoConfig.from_pretrained(lowercase ) self.assertIsNotNone(lowercase ) self.assertIsInstance(lowercase , lowercase ) _lowerCamelCase : str = TFAutoModelWithLMHead.from_pretrained(lowercase ) self.assertIsNotNone(lowercase ) self.assertIsInstance(lowercase , lowercase ) @slow def A_ ( self ): for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _lowerCamelCase : Tuple = AutoConfig.from_pretrained(lowercase ) self.assertIsNotNone(lowercase ) self.assertIsInstance(lowercase , lowercase ) _lowerCamelCase : Optional[int] = TFAutoModelForMaskedLM.from_pretrained(lowercase ) _lowerCamelCase, _lowerCamelCase : Tuple = TFAutoModelForMaskedLM.from_pretrained(lowercase , output_loading_info=lowercase ) self.assertIsNotNone(lowercase ) self.assertIsInstance(lowercase , lowercase ) @slow def A_ ( self ): for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _lowerCamelCase : Optional[int] = AutoConfig.from_pretrained(lowercase ) self.assertIsNotNone(lowercase ) self.assertIsInstance(lowercase , lowercase ) _lowerCamelCase : Tuple = TFAutoModelForSeqaSeqLM.from_pretrained(lowercase ) _lowerCamelCase, _lowerCamelCase : Tuple = TFAutoModelForSeqaSeqLM.from_pretrained(lowercase , output_loading_info=lowercase ) self.assertIsNotNone(lowercase ) self.assertIsInstance(lowercase , lowercase ) @slow def A_ ( self ): # for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: for model_name in ["bert-base-uncased"]: _lowerCamelCase : str = AutoConfig.from_pretrained(lowercase ) self.assertIsNotNone(lowercase ) self.assertIsInstance(lowercase , lowercase ) _lowerCamelCase : Union[str, Any] = TFAutoModelForSequenceClassification.from_pretrained(lowercase ) self.assertIsNotNone(lowercase ) self.assertIsInstance(lowercase , lowercase ) @slow def A_ ( self ): # for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: for model_name in ["bert-base-uncased"]: _lowerCamelCase : Optional[Any] = AutoConfig.from_pretrained(lowercase ) self.assertIsNotNone(lowercase ) self.assertIsInstance(lowercase , lowercase ) _lowerCamelCase : List[str] = TFAutoModelForQuestionAnswering.from_pretrained(lowercase ) self.assertIsNotNone(lowercase ) self.assertIsInstance(lowercase , lowercase ) @slow @require_tensorflow_probability def A_ ( self ): for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]: _lowerCamelCase : Dict = AutoConfig.from_pretrained(lowercase ) self.assertIsNotNone(lowercase ) self.assertIsInstance(lowercase , lowercase ) _lowerCamelCase : Dict = TFAutoModelForTableQuestionAnswering.from_pretrained(lowercase ) _lowerCamelCase, _lowerCamelCase : List[Any] = TFAutoModelForTableQuestionAnswering.from_pretrained( lowercase , output_loading_info=lowercase ) self.assertIsNotNone(lowercase ) self.assertIsInstance(lowercase , lowercase ) def A_ ( self ): _lowerCamelCase : int = TFAutoModelWithLMHead.from_pretrained(lowercase ) self.assertIsInstance(lowercase , lowercase ) self.assertEqual(model.num_parameters() , 14410 ) self.assertEqual(model.num_parameters(only_trainable=lowercase ) , 14410 ) def A_ ( self ): _lowerCamelCase : Any = TFAutoModelWithLMHead.from_pretrained(lowercase ) self.assertIsInstance(lowercase , lowercase ) self.assertEqual(model.num_parameters() , 14410 ) self.assertEqual(model.num_parameters(only_trainable=lowercase ) , 14410 ) def A_ ( self ): # For the auto model mapping, FunnelConfig has two models: FunnelModel and FunnelBaseModel _lowerCamelCase : List[str] = TFAutoModel.from_pretrained('sgugger/funnel-random-tiny' ) self.assertIsInstance(lowercase , lowercase ) _lowerCamelCase : Optional[int] = copy.deepcopy(model.config ) _lowerCamelCase : Dict = ['FunnelBaseModel'] _lowerCamelCase : List[Any] = TFAutoModel.from_config(lowercase ) self.assertIsInstance(lowercase , lowercase ) with tempfile.TemporaryDirectory() as tmp_dir: model.save_pretrained(lowercase ) _lowerCamelCase : Tuple = TFAutoModel.from_pretrained(lowercase ) self.assertIsInstance(lowercase , lowercase ) def A_ ( self ): try: AutoConfig.register('new-model' , lowercase ) _lowerCamelCase : Tuple = [ TFAutoModel, TFAutoModelForCausalLM, TFAutoModelForMaskedLM, TFAutoModelForPreTraining, TFAutoModelForQuestionAnswering, TFAutoModelForSequenceClassification, TFAutoModelForTokenClassification, ] for auto_class in auto_classes: with self.subTest(auto_class.__name__ ): # Wrong config class will raise an error with self.assertRaises(lowercase ): auto_class.register(lowercase , lowercase ) auto_class.register(lowercase , lowercase ) # Trying to register something existing in the Transformers library will raise an error with self.assertRaises(lowercase ): auto_class.register(lowercase , lowercase ) # Now that the config is registered, it can be used as any other config with the auto-API _lowerCamelCase : Optional[Any] = BertModelTester(self ).get_config() _lowerCamelCase : Dict = NewModelConfig(**tiny_config.to_dict() ) _lowerCamelCase : int = auto_class.from_config(lowercase ) self.assertIsInstance(lowercase , lowercase ) with tempfile.TemporaryDirectory() as tmp_dir: model.save_pretrained(lowercase ) _lowerCamelCase : List[Any] = auto_class.from_pretrained(lowercase ) self.assertIsInstance(lowercase , lowercase ) finally: if "new-model" in CONFIG_MAPPING._extra_content: del CONFIG_MAPPING._extra_content["new-model"] for mapping in ( TF_MODEL_MAPPING, TF_MODEL_FOR_PRETRAINING_MAPPING, TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING, TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING, TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING, TF_MODEL_FOR_CAUSAL_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, ): if NewModelConfig in mapping._extra_content: del mapping._extra_content[NewModelConfig] def A_ ( self ): with self.assertRaisesRegex( lowercase , 'bert-base is not a local folder and is not a valid model identifier' ): _lowerCamelCase : Union[str, Any] = TFAutoModel.from_pretrained('bert-base' ) def A_ ( self ): with self.assertRaisesRegex( lowercase , r'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)' ): _lowerCamelCase : str = TFAutoModel.from_pretrained(lowercase , revision='aaaaaa' ) def A_ ( self ): with self.assertRaisesRegex( lowercase , 'hf-internal-testing/config-no-model does not appear to have a file named pytorch_model.bin' , ): _lowerCamelCase : Tuple = TFAutoModel.from_pretrained('hf-internal-testing/config-no-model' ) def A_ ( self ): with self.assertRaisesRegex(lowercase , 'Use `from_pt=True` to load this model' ): _lowerCamelCase : Tuple = TFAutoModel.from_pretrained('hf-internal-testing/tiny-bert-pt-only' ) def A_ ( self ): # Make sure we have cached the model. _lowerCamelCase : Optional[int] = TFAutoModel.from_pretrained('hf-internal-testing/tiny-random-bert' ) with RequestCounter() as counter: _lowerCamelCase : Optional[int] = TFAutoModel.from_pretrained('hf-internal-testing/tiny-random-bert' ) self.assertEqual(counter.get_request_count , 0 ) self.assertEqual(counter.head_request_count , 1 ) self.assertEqual(counter.other_request_count , 0 ) # With a sharded checkpoint _lowerCamelCase : int = TFAutoModel.from_pretrained('ArthurZ/tiny-random-bert-sharded' ) with RequestCounter() as counter: _lowerCamelCase : List[Any] = TFAutoModel.from_pretrained('ArthurZ/tiny-random-bert-sharded' ) self.assertEqual(counter.get_request_count , 0 ) self.assertEqual(counter.head_request_count , 1 ) self.assertEqual(counter.other_request_count , 0 )
96
0
import unittest from transformers import TrOCRConfig from transformers.testing_utils import is_torch_available, require_torch, 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.models.trocr.modeling_trocr import TrOCRDecoder, TrOCRForCausalLM @require_torch class UpperCamelCase_ : def __init__( self , lowerCAmelCase_ , lowerCAmelCase_=99 , lowerCAmelCase_=13 , lowerCAmelCase_=16 , lowerCAmelCase_=7 , lowerCAmelCase_=True , lowerCAmelCase_=True , lowerCAmelCase_=True , lowerCAmelCase_=False , lowerCAmelCase_=True , lowerCAmelCase_=2 , lowerCAmelCase_=32 , lowerCAmelCase_=4 , lowerCAmelCase_=4 , lowerCAmelCase_=30 , lowerCAmelCase_=0 , lowerCAmelCase_=1 , lowerCAmelCase_=2 , lowerCAmelCase_=None , ) -> Dict: _snake_case = parent _snake_case = batch_size _snake_case = decoder_seq_length # For common tests _snake_case = self.decoder_seq_length _snake_case = is_training _snake_case = use_attention_mask _snake_case = use_labels _snake_case = vocab_size _snake_case = d_model _snake_case = d_model _snake_case = decoder_layers _snake_case = decoder_layers _snake_case = decoder_ffn_dim _snake_case = decoder_attention_heads _snake_case = decoder_attention_heads _snake_case = eos_token_id _snake_case = bos_token_id _snake_case = pad_token_id _snake_case = decoder_start_token_id _snake_case = use_cache _snake_case = max_position_embeddings _snake_case = None _snake_case = decoder_seq_length _snake_case = 2 _snake_case = 1 def lowerCAmelCase ( self ) -> Optional[int]: _snake_case = ids_tensor([self.batch_size, self.decoder_seq_length] , self.vocab_size ) _snake_case = None if self.use_attention_mask: _snake_case = ids_tensor([self.batch_size, self.decoder_seq_length] , vocab_size=2 ) _snake_case = None if self.use_labels: _snake_case = ids_tensor([self.batch_size, self.decoder_seq_length] , self.vocab_size ) _snake_case = TrOCRConfig( vocab_size=self.vocab_size , d_model=self.d_model , decoder_layers=self.decoder_layers , decoder_ffn_dim=self.decoder_ffn_dim , decoder_attention_heads=self.decoder_attention_heads , eos_token_id=self.eos_token_id , bos_token_id=self.bos_token_id , use_cache=self.use_cache , pad_token_id=self.pad_token_id , decoder_start_token_id=self.decoder_start_token_id , max_position_embeddings=self.max_position_embeddings , ) return (config, input_ids, attention_mask, lm_labels) def lowerCAmelCase ( self , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , ) -> List[str]: _snake_case = True _snake_case = TrOCRDecoder(config=lowerCAmelCase_ ).to(lowerCAmelCase_ ).eval() _snake_case = input_ids[:2] input_ids[input_ids == 0] += 1 # first forward pass _snake_case = model(lowerCAmelCase_ , use_cache=lowerCAmelCase_ ) _snake_case = model(lowerCAmelCase_ ) _snake_case = model(lowerCAmelCase_ , use_cache=lowerCAmelCase_ ) self.parent.assertTrue(len(lowerCAmelCase_ ) == len(lowerCAmelCase_ ) ) self.parent.assertTrue(len(lowerCAmelCase_ ) == len(lowerCAmelCase_ ) + 1 ) _snake_case = outputs['past_key_values'] # create hypothetical next token and extent to next_input_ids _snake_case = ids_tensor((2, 1) , config.vocab_size - 1 ) + 1 # append to next input_ids and _snake_case = torch.cat([input_ids, next_tokens] , dim=-1 ) _snake_case = model(lowerCAmelCase_ )['last_hidden_state'] _snake_case = model(lowerCAmelCase_ , past_key_values=lowerCAmelCase_ )['last_hidden_state'] # select random slice _snake_case = ids_tensor((1,) , output_from_past.shape[-1] ).item() _snake_case = output_from_no_past[:, next_input_ids.shape[-1] - 1, random_slice_idx].detach() _snake_case = output_from_past[:, 0, random_slice_idx].detach() # test that outputs are equal for slice assert torch.allclose(lowerCAmelCase_ , lowerCAmelCase_ , atol=1E-3 ) def lowerCAmelCase ( self ) -> Any: _snake_case = self.prepare_config_and_inputs() _snake_case , _snake_case , _snake_case , _snake_case = config_and_inputs _snake_case = {'input_ids': input_ids, 'attention_mask': attention_mask} return config, inputs_dict @require_torch class UpperCamelCase_ ( _lowerCamelCase , _lowerCamelCase , _lowerCamelCase , unittest.TestCase ): lowerCAmelCase_ = (TrOCRDecoder, TrOCRForCausalLM) if is_torch_available() else () lowerCAmelCase_ = (TrOCRForCausalLM,) if is_torch_available() else () lowerCAmelCase_ = {'''text-generation''': TrOCRForCausalLM} if is_torch_available() else {} lowerCAmelCase_ = True lowerCAmelCase_ = False def lowerCAmelCase ( self ) -> Tuple: _snake_case = TrOCRStandaloneDecoderModelTester(self , is_training=lowerCAmelCase_ ) _snake_case = ConfigTester(self , config_class=lowerCAmelCase_ ) def lowerCAmelCase ( self ) -> List[str]: pass def lowerCAmelCase ( self ) -> str: pass def lowerCAmelCase ( self ) -> int: pass def lowerCAmelCase ( self ) -> List[str]: self.config_tester.run_common_tests() def lowerCAmelCase ( self ) -> List[str]: _snake_case = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_decoder_model_past(*lowerCAmelCase_ ) def lowerCAmelCase ( self ) -> List[Any]: return @unittest.skip('The model doesn\'t support left padding' ) # and it's not used enough to be worth fixing :) def lowerCAmelCase ( self ) -> Optional[int]: pass
367
import os import unittest from transformers import BertTokenizerFast from transformers.models.bert.tokenization_bert import ( VOCAB_FILES_NAMES, BasicTokenizer, BertTokenizer, WordpieceTokenizer, _is_control, _is_punctuation, _is_whitespace, ) from transformers.testing_utils import require_tokenizers, slow from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english @require_tokenizers class UpperCamelCase_ ( _lowerCamelCase , unittest.TestCase ): lowerCAmelCase_ = BertTokenizer lowerCAmelCase_ = BertTokenizerFast lowerCAmelCase_ = True lowerCAmelCase_ = True lowerCAmelCase_ = filter_non_english def lowerCAmelCase ( self ) -> Optional[int]: super().setUp() _snake_case = [ '[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing', ',', 'low', 'lowest', ] _snake_case = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['vocab_file'] ) with open(self.vocab_file , 'w' , encoding='utf-8' ) as vocab_writer: vocab_writer.write(''.join([x + '\n' for x in vocab_tokens] ) ) def lowerCAmelCase ( self , lowerCAmelCase_ ) -> Optional[Any]: _snake_case = 'UNwant\u00E9d,running' _snake_case = 'unwanted, running' return input_text, output_text def lowerCAmelCase ( self ) -> List[Any]: _snake_case = self.tokenizer_class(self.vocab_file ) _snake_case = tokenizer.tokenize('UNwant\u00E9d,running' ) self.assertListEqual(lowerCAmelCase_ , ['un', '##want', '##ed', ',', 'runn', '##ing'] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCAmelCase_ ) , [9, 6, 7, 12, 10, 11] ) def lowerCAmelCase ( self ) -> Tuple: if not self.test_rust_tokenizer: return _snake_case = self.get_tokenizer() _snake_case = self.get_rust_tokenizer() _snake_case = 'UNwant\u00E9d,running' _snake_case = tokenizer.tokenize(lowerCAmelCase_ ) _snake_case = rust_tokenizer.tokenize(lowerCAmelCase_ ) self.assertListEqual(lowerCAmelCase_ , lowerCAmelCase_ ) _snake_case = tokenizer.encode(lowerCAmelCase_ , add_special_tokens=lowerCAmelCase_ ) _snake_case = rust_tokenizer.encode(lowerCAmelCase_ , add_special_tokens=lowerCAmelCase_ ) self.assertListEqual(lowerCAmelCase_ , lowerCAmelCase_ ) _snake_case = self.get_rust_tokenizer() _snake_case = tokenizer.encode(lowerCAmelCase_ ) _snake_case = rust_tokenizer.encode(lowerCAmelCase_ ) self.assertListEqual(lowerCAmelCase_ , lowerCAmelCase_ ) # With lower casing _snake_case = self.get_tokenizer(do_lower_case=lowerCAmelCase_ ) _snake_case = self.get_rust_tokenizer(do_lower_case=lowerCAmelCase_ ) _snake_case = 'UNwant\u00E9d,running' _snake_case = tokenizer.tokenize(lowerCAmelCase_ ) _snake_case = rust_tokenizer.tokenize(lowerCAmelCase_ ) self.assertListEqual(lowerCAmelCase_ , lowerCAmelCase_ ) _snake_case = tokenizer.encode(lowerCAmelCase_ , add_special_tokens=lowerCAmelCase_ ) _snake_case = rust_tokenizer.encode(lowerCAmelCase_ , add_special_tokens=lowerCAmelCase_ ) self.assertListEqual(lowerCAmelCase_ , lowerCAmelCase_ ) _snake_case = self.get_rust_tokenizer() _snake_case = tokenizer.encode(lowerCAmelCase_ ) _snake_case = rust_tokenizer.encode(lowerCAmelCase_ ) self.assertListEqual(lowerCAmelCase_ , lowerCAmelCase_ ) def lowerCAmelCase ( self ) -> List[str]: _snake_case = BasicTokenizer() self.assertListEqual(tokenizer.tokenize('ah\u535A\u63A8zz' ) , ['ah', '\u535A', '\u63A8', 'zz'] ) def lowerCAmelCase ( self ) -> Optional[Any]: _snake_case = BasicTokenizer(do_lower_case=lowerCAmelCase_ ) self.assertListEqual( tokenizer.tokenize(' \tHeLLo!how \n Are yoU? ' ) , ['hello', '!', 'how', 'are', 'you', '?'] ) self.assertListEqual(tokenizer.tokenize('H\u00E9llo' ) , ['hello'] ) def lowerCAmelCase ( self ) -> List[Any]: _snake_case = BasicTokenizer(do_lower_case=lowerCAmelCase_ , strip_accents=lowerCAmelCase_ ) self.assertListEqual( tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['hällo', '!', 'how', 'are', 'you', '?'] ) self.assertListEqual(tokenizer.tokenize('H\u00E9llo' ) , ['h\u00E9llo'] ) def lowerCAmelCase ( self ) -> Any: _snake_case = BasicTokenizer(do_lower_case=lowerCAmelCase_ , strip_accents=lowerCAmelCase_ ) self.assertListEqual( tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['hallo', '!', 'how', 'are', 'you', '?'] ) self.assertListEqual(tokenizer.tokenize('H\u00E9llo' ) , ['hello'] ) def lowerCAmelCase ( self ) -> List[str]: _snake_case = BasicTokenizer(do_lower_case=lowerCAmelCase_ ) self.assertListEqual( tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['hallo', '!', 'how', 'are', 'you', '?'] ) self.assertListEqual(tokenizer.tokenize('H\u00E9llo' ) , ['hello'] ) def lowerCAmelCase ( self ) -> Tuple: _snake_case = BasicTokenizer(do_lower_case=lowerCAmelCase_ ) self.assertListEqual( tokenizer.tokenize(' \tHeLLo!how \n Are yoU? ' ) , ['HeLLo', '!', 'how', 'Are', 'yoU', '?'] ) def lowerCAmelCase ( self ) -> Union[str, Any]: _snake_case = BasicTokenizer(do_lower_case=lowerCAmelCase_ , strip_accents=lowerCAmelCase_ ) self.assertListEqual( tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['HäLLo', '!', 'how', 'Are', 'yoU', '?'] ) def lowerCAmelCase ( self ) -> Tuple: _snake_case = BasicTokenizer(do_lower_case=lowerCAmelCase_ , strip_accents=lowerCAmelCase_ ) self.assertListEqual( tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['HaLLo', '!', 'how', 'Are', 'yoU', '?'] ) def lowerCAmelCase ( self ) -> Dict: _snake_case = BasicTokenizer(do_lower_case=lowerCAmelCase_ , never_split=['[UNK]'] ) self.assertListEqual( tokenizer.tokenize(' \tHeLLo!how \n Are yoU? [UNK]' ) , ['HeLLo', '!', 'how', 'Are', 'yoU', '?', '[UNK]'] ) def lowerCAmelCase ( self ) -> Union[str, Any]: _snake_case = BasicTokenizer() _snake_case = 'a\n\'ll !!to?\'d of, can\'t.' _snake_case = ['a', '\'', 'll', '!', '!', 'to', '?', '\'', 'd', 'of', ',', 'can', '\'', 't', '.'] self.assertListEqual(tokenizer.tokenize(lowerCAmelCase_ ) , lowerCAmelCase_ ) def lowerCAmelCase ( self ) -> Union[str, Any]: _snake_case = ['[UNK]', '[CLS]', '[SEP]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing'] _snake_case = {} for i, token in enumerate(lowerCAmelCase_ ): _snake_case = i _snake_case = WordpieceTokenizer(vocab=lowerCAmelCase_ , unk_token='[UNK]' ) self.assertListEqual(tokenizer.tokenize('' ) , [] ) self.assertListEqual(tokenizer.tokenize('unwanted running' ) , ['un', '##want', '##ed', 'runn', '##ing'] ) self.assertListEqual(tokenizer.tokenize('unwantedX running' ) , ['[UNK]', 'runn', '##ing'] ) def lowerCAmelCase ( self ) -> Tuple: self.assertTrue(_is_whitespace(' ' ) ) self.assertTrue(_is_whitespace('\t' ) ) self.assertTrue(_is_whitespace('\r' ) ) self.assertTrue(_is_whitespace('\n' ) ) self.assertTrue(_is_whitespace('\u00A0' ) ) self.assertFalse(_is_whitespace('A' ) ) self.assertFalse(_is_whitespace('-' ) ) def lowerCAmelCase ( self ) -> Dict: self.assertTrue(_is_control('\u0005' ) ) self.assertFalse(_is_control('A' ) ) self.assertFalse(_is_control(' ' ) ) self.assertFalse(_is_control('\t' ) ) self.assertFalse(_is_control('\r' ) ) def lowerCAmelCase ( self ) -> int: self.assertTrue(_is_punctuation('-' ) ) self.assertTrue(_is_punctuation('$' ) ) self.assertTrue(_is_punctuation('`' ) ) self.assertTrue(_is_punctuation('.' ) ) self.assertFalse(_is_punctuation('A' ) ) self.assertFalse(_is_punctuation(' ' ) ) def lowerCAmelCase ( self ) -> Tuple: _snake_case = self.get_tokenizer() _snake_case = self.get_rust_tokenizer() # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340 self.assertListEqual([tokenizer.tokenize(lowerCAmelCase_ ) for t in ['Test', '\xad', 'test']] , [['[UNK]'], [], ['[UNK]']] ) self.assertListEqual( [rust_tokenizer.tokenize(lowerCAmelCase_ ) for t in ['Test', '\xad', 'test']] , [['[UNK]'], [], ['[UNK]']] ) @slow def lowerCAmelCase ( self ) -> Optional[Any]: _snake_case = self.tokenizer_class.from_pretrained('bert-base-uncased' ) _snake_case = tokenizer.encode('sequence builders' , add_special_tokens=lowerCAmelCase_ ) _snake_case = tokenizer.encode('multi-sequence build' , add_special_tokens=lowerCAmelCase_ ) _snake_case = tokenizer.build_inputs_with_special_tokens(lowerCAmelCase_ ) _snake_case = tokenizer.build_inputs_with_special_tokens(lowerCAmelCase_ , lowerCAmelCase_ ) assert encoded_sentence == [101] + text + [102] assert encoded_pair == [101] + text + [102] + text_a + [102] def lowerCAmelCase ( self ) -> Union[str, Any]: for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})''' ): _snake_case = self.rust_tokenizer_class.from_pretrained(lowerCAmelCase_ , **lowerCAmelCase_ ) _snake_case = F'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.''' _snake_case = tokenizer_r.encode_plus( lowerCAmelCase_ , return_attention_mask=lowerCAmelCase_ , return_token_type_ids=lowerCAmelCase_ , return_offsets_mapping=lowerCAmelCase_ , add_special_tokens=lowerCAmelCase_ , ) _snake_case = tokenizer_r.do_lower_case if hasattr(lowerCAmelCase_ , 'do_lower_case' ) else False _snake_case = ( [ ((0, 0), tokenizer_r.cls_token), ((0, 1), 'A'), ((1, 2), ','), ((3, 5), 'na'), ((5, 6), '##ï'), ((6, 8), '##ve'), ((9, 15), tokenizer_r.mask_token), ((16, 21), 'Allen'), ((21, 23), '##NL'), ((23, 24), '##P'), ((25, 33), 'sentence'), ((33, 34), '.'), ((0, 0), tokenizer_r.sep_token), ] if not do_lower_case else [ ((0, 0), tokenizer_r.cls_token), ((0, 1), 'a'), ((1, 2), ','), ((3, 8), 'naive'), ((9, 15), tokenizer_r.mask_token), ((16, 21), 'allen'), ((21, 23), '##nl'), ((23, 24), '##p'), ((25, 33), 'sentence'), ((33, 34), '.'), ((0, 0), tokenizer_r.sep_token), ] ) self.assertEqual( [e[1] for e in expected_results] , tokenizer_r.convert_ids_to_tokens(tokens['input_ids'] ) ) self.assertEqual([e[0] for e in expected_results] , tokens['offset_mapping'] ) def lowerCAmelCase ( self ) -> str: _snake_case = ['的', '人', '有'] _snake_case = ''.join(lowerCAmelCase_ ) for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})''' ): _snake_case = True _snake_case = self.tokenizer_class.from_pretrained(lowerCAmelCase_ , **lowerCAmelCase_ ) _snake_case = self.rust_tokenizer_class.from_pretrained(lowerCAmelCase_ , **lowerCAmelCase_ ) _snake_case = tokenizer_p.encode(lowerCAmelCase_ , add_special_tokens=lowerCAmelCase_ ) _snake_case = tokenizer_r.encode(lowerCAmelCase_ , add_special_tokens=lowerCAmelCase_ ) _snake_case = tokenizer_r.convert_ids_to_tokens(lowerCAmelCase_ ) _snake_case = tokenizer_p.convert_ids_to_tokens(lowerCAmelCase_ ) # it is expected that each Chinese character is not preceded by "##" self.assertListEqual(lowerCAmelCase_ , lowerCAmelCase_ ) self.assertListEqual(lowerCAmelCase_ , lowerCAmelCase_ ) _snake_case = False _snake_case = self.rust_tokenizer_class.from_pretrained(lowerCAmelCase_ , **lowerCAmelCase_ ) _snake_case = self.tokenizer_class.from_pretrained(lowerCAmelCase_ , **lowerCAmelCase_ ) _snake_case = tokenizer_r.encode(lowerCAmelCase_ , add_special_tokens=lowerCAmelCase_ ) _snake_case = tokenizer_p.encode(lowerCAmelCase_ , add_special_tokens=lowerCAmelCase_ ) _snake_case = tokenizer_r.convert_ids_to_tokens(lowerCAmelCase_ ) _snake_case = tokenizer_p.convert_ids_to_tokens(lowerCAmelCase_ ) # it is expected that only the first Chinese character is not preceded by "##". _snake_case = [ F'''##{token}''' if idx != 0 else token for idx, token in enumerate(lowerCAmelCase_ ) ] self.assertListEqual(lowerCAmelCase_ , lowerCAmelCase_ ) self.assertListEqual(lowerCAmelCase_ , lowerCAmelCase_ )
295
0
'''simple docstring''' import unittest from transformers import DebertaConfig, is_torch_available from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device 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 ( DebertaForMaskedLM, DebertaForQuestionAnswering, DebertaForSequenceClassification, DebertaForTokenClassification, DebertaModel, ) from transformers.models.deberta.modeling_deberta import DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST class a ( _lowerCamelCase ): def __init__( self : Tuple , lowercase_ : Union[str, Any] , lowercase_ : Dict=13 , lowercase_ : Tuple=7 , lowercase_ : List[Any]=True , lowercase_ : Any=True , lowercase_ : Union[str, Any]=True , lowercase_ : Tuple=True , lowercase_ : List[Any]=99 , lowercase_ : int=32 , lowercase_ : List[str]=5 , lowercase_ : str=4 , lowercase_ : Optional[Any]=37 , lowercase_ : List[str]="gelu" , lowercase_ : List[str]=0.1 , lowercase_ : int=0.1 , lowercase_ : Tuple=512 , lowercase_ : List[Any]=16 , lowercase_ : Optional[int]=2 , lowercase_ : Optional[int]=0.02 , lowercase_ : List[Any]=False , lowercase_ : Dict=True , lowercase_ : List[str]="None" , lowercase_ : List[str]=3 , lowercase_ : Optional[Any]=4 , lowercase_ : Tuple=None , ): snake_case_ = parent snake_case_ = batch_size snake_case_ = seq_length snake_case_ = is_training snake_case_ = use_input_mask snake_case_ = use_token_type_ids snake_case_ = use_labels snake_case_ = vocab_size snake_case_ = hidden_size snake_case_ = num_hidden_layers snake_case_ = num_attention_heads snake_case_ = intermediate_size snake_case_ = hidden_act snake_case_ = hidden_dropout_prob snake_case_ = attention_probs_dropout_prob snake_case_ = max_position_embeddings snake_case_ = type_vocab_size snake_case_ = type_sequence_label_size snake_case_ = initializer_range snake_case_ = num_labels snake_case_ = num_choices snake_case_ = relative_attention snake_case_ = position_biased_input snake_case_ = pos_att_type snake_case_ = scope def A_ ( self : Any ): snake_case_ = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) snake_case_ = None if self.use_input_mask: snake_case_ = ids_tensor([self.batch_size, self.seq_length] , vocab_size=2 ) snake_case_ = None if self.use_token_type_ids: snake_case_ = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) snake_case_ = None snake_case_ = None snake_case_ = None if self.use_labels: snake_case_ = ids_tensor([self.batch_size] , self.type_sequence_label_size ) snake_case_ = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) snake_case_ = ids_tensor([self.batch_size] , self.num_choices ) snake_case_ = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def A_ ( self : Dict ): return DebertaConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , initializer_range=self.initializer_range , relative_attention=self.relative_attention , position_biased_input=self.position_biased_input , pos_att_type=self.pos_att_type , ) def A_ ( self : List[str] ): snake_case_ = self.get_config() snake_case_ = 300 return config def A_ ( self : Tuple , lowercase_ : List[str] ): self.parent.assertListEqual(list(result.loss.size() ) , [] ) def A_ ( self : Tuple , lowercase_ : List[Any] , lowercase_ : Tuple , lowercase_ : List[str] , lowercase_ : Any , lowercase_ : Dict , lowercase_ : Tuple , lowercase_ : Optional[Any] ): snake_case_ = DebertaModel(config=lowercase_ ) model.to(lowercase_ ) model.eval() snake_case_ = model(lowercase_ , attention_mask=lowercase_ , token_type_ids=lowercase_ )[0] snake_case_ = model(lowercase_ , token_type_ids=lowercase_ )[0] snake_case_ = model(lowercase_ )[0] self.parent.assertListEqual(list(sequence_output.size() ) , [self.batch_size, self.seq_length, self.hidden_size] ) def A_ ( self : Any , lowercase_ : Optional[Any] , lowercase_ : Union[str, Any] , lowercase_ : Union[str, Any] , lowercase_ : List[str] , lowercase_ : List[str] , lowercase_ : List[Any] , lowercase_ : Any ): snake_case_ = DebertaForMaskedLM(config=lowercase_ ) model.to(lowercase_ ) model.eval() snake_case_ = model(lowercase_ , attention_mask=lowercase_ , token_type_ids=lowercase_ , labels=lowercase_ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def A_ ( self : Optional[int] , lowercase_ : List[str] , lowercase_ : Tuple , lowercase_ : List[str] , lowercase_ : Dict , lowercase_ : Union[str, Any] , lowercase_ : Dict , lowercase_ : Optional[Any] ): snake_case_ = self.num_labels snake_case_ = DebertaForSequenceClassification(lowercase_ ) model.to(lowercase_ ) model.eval() snake_case_ = model(lowercase_ , attention_mask=lowercase_ , token_type_ids=lowercase_ , labels=lowercase_ ) self.parent.assertListEqual(list(result.logits.size() ) , [self.batch_size, self.num_labels] ) self.check_loss_output(lowercase_ ) def A_ ( self : List[Any] , lowercase_ : List[str] , lowercase_ : Tuple , lowercase_ : Dict , lowercase_ : List[Any] , lowercase_ : List[Any] , lowercase_ : Dict , lowercase_ : List[str] ): snake_case_ = self.num_labels snake_case_ = DebertaForTokenClassification(config=lowercase_ ) model.to(lowercase_ ) model.eval() snake_case_ = model(lowercase_ , attention_mask=lowercase_ , token_type_ids=lowercase_ , labels=lowercase_ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def A_ ( self : List[str] , lowercase_ : List[str] , lowercase_ : int , lowercase_ : Optional[int] , lowercase_ : Tuple , lowercase_ : Dict , lowercase_ : Optional[int] , lowercase_ : Optional[Any] ): snake_case_ = DebertaForQuestionAnswering(config=lowercase_ ) model.to(lowercase_ ) model.eval() snake_case_ = model( lowercase_ , attention_mask=lowercase_ , token_type_ids=lowercase_ , start_positions=lowercase_ , end_positions=lowercase_ , ) self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) ) def A_ ( self : Tuple ): snake_case_ = self.prepare_config_and_inputs() ( ( snake_case_ ) ,( snake_case_ ) ,( snake_case_ ) ,( snake_case_ ) ,( snake_case_ ) ,( snake_case_ ) ,( snake_case_ ) , ) = config_and_inputs snake_case_ = {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask} return config, inputs_dict @require_torch class a ( _lowerCamelCase , _lowerCamelCase , unittest.TestCase ): snake_case_ = ( ( DebertaModel, DebertaForMaskedLM, DebertaForSequenceClassification, DebertaForTokenClassification, DebertaForQuestionAnswering, ) if is_torch_available() else () ) snake_case_ = ( { "feature-extraction": DebertaModel, "fill-mask": DebertaForMaskedLM, "question-answering": DebertaForQuestionAnswering, "text-classification": DebertaForSequenceClassification, "token-classification": DebertaForTokenClassification, "zero-shot": DebertaForSequenceClassification, } if is_torch_available() else {} ) snake_case_ = True snake_case_ = False snake_case_ = False snake_case_ = False snake_case_ = False def A_ ( self : Optional[Any] ): snake_case_ = DebertaModelTester(self ) snake_case_ = ConfigTester(self , config_class=lowercase_ , hidden_size=37 ) def A_ ( self : List[Any] ): self.config_tester.run_common_tests() def A_ ( self : int ): snake_case_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_deberta_model(*lowercase_ ) def A_ ( self : Tuple ): snake_case_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_deberta_for_sequence_classification(*lowercase_ ) def A_ ( self : int ): snake_case_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_deberta_for_masked_lm(*lowercase_ ) def A_ ( self : int ): snake_case_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_deberta_for_question_answering(*lowercase_ ) def A_ ( self : Union[str, Any] ): snake_case_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_deberta_for_token_classification(*lowercase_ ) @slow def A_ ( self : List[str] ): for model_name in DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: snake_case_ = DebertaModel.from_pretrained(lowercase_ ) self.assertIsNotNone(lowercase_ ) @require_torch @require_sentencepiece @require_tokenizers class a ( unittest.TestCase ): @unittest.skip(reason='''Model not available yet''' ) def A_ ( self : Optional[int] ): pass @slow def A_ ( self : str ): snake_case_ = DebertaModel.from_pretrained('''microsoft/deberta-base''' ) snake_case_ = torch.tensor([[0, 3_1414, 232, 328, 740, 1140, 1_2695, 69, 4_6078, 1588, 2]] ) snake_case_ = torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] ) with torch.no_grad(): snake_case_ = model(lowercase_ , attention_mask=lowercase_ )[0] # compare the actual values for a slice. snake_case_ = torch.tensor( [[[-0.5986, -0.8055, -0.8462], [1.4484, -0.9348, -0.8059], [0.3123, 0.0032, -1.4131]]] ) self.assertTrue(torch.allclose(output[:, 1:4, 1:4] , lowercase_ , atol=1e-4 ) , F"{output[:, 1:4, 1:4]}" )
56
'''simple docstring''' from collections import defaultdict def __magic_name__ ( __UpperCAmelCase ) -> int: '''simple docstring''' snake_case_ = 1 snake_case_ = True for v in tree[start]: if v not in visited: ret += dfs(__UpperCAmelCase ) if ret % 2 == 0: cuts.append(__UpperCAmelCase ) return ret def __magic_name__ ( ) -> Union[str, Any]: '''simple docstring''' dfs(1 ) if __name__ == "__main__": a ,a : Dict = 10, 9 a : Dict = defaultdict(list) a : dict[int, bool] = {} a : list[int] = [] a : Tuple = 0 a : str = [(2, 1), (3, 1), (4, 3), (5, 2), (6, 1), (7, 2), (8, 6), (9, 8), (10, 8)] for u, v in edges: tree[u].append(v) tree[v].append(u) even_tree() print(len(cuts) - 1)
56
1
import pickle import shutil import tempfile import unittest from transformers import SPIECE_UNDERLINE, XLMRobertaTokenizer, XLMRobertaTokenizerFast from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow from transformers.utils import cached_property from ...test_tokenization_common import TokenizerTesterMixin lowercase : Optional[int] = get_tests_dir('''fixtures/test_sentencepiece.model''') @require_sentencepiece @require_tokenizers class UpperCAmelCase_ ( SCREAMING_SNAKE_CASE__ , unittest.TestCase ): '''simple docstring''' A : List[str] = XLMRobertaTokenizer A : List[Any] = XLMRobertaTokenizerFast A : List[str] = True A : int = True def _lowerCAmelCase ( self ) -> Tuple: super().setUp() # We have a SentencePiece fixture for testing snake_case_ : List[str] = XLMRobertaTokenizer(_SCREAMING_SNAKE_CASE , keep_accents=_SCREAMING_SNAKE_CASE ) tokenizer.save_pretrained(self.tmpdirname ) def _lowerCAmelCase ( self ) -> Any: snake_case_ : Any = "<pad>" snake_case_ : str = 1 self.assertEqual(self.get_tokenizer()._convert_token_to_id(_SCREAMING_SNAKE_CASE ) , _SCREAMING_SNAKE_CASE ) self.assertEqual(self.get_tokenizer()._convert_id_to_token(_SCREAMING_SNAKE_CASE ) , _SCREAMING_SNAKE_CASE ) def _lowerCAmelCase ( self ) -> Any: snake_case_ : Optional[int] = 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(_SCREAMING_SNAKE_CASE ) , 1002 ) def _lowerCAmelCase ( self ) -> Union[str, Any]: self.assertEqual(self.get_tokenizer().vocab_size , 1002 ) def _lowerCAmelCase ( self ) -> Dict: snake_case_ : Any = XLMRobertaTokenizer(_SCREAMING_SNAKE_CASE , keep_accents=_SCREAMING_SNAKE_CASE ) snake_case_ : Dict = tokenizer.tokenize("This is a test" ) self.assertListEqual(_SCREAMING_SNAKE_CASE , ["▁This", "▁is", "▁a", "▁t", "est"] ) self.assertListEqual( tokenizer.convert_tokens_to_ids(_SCREAMING_SNAKE_CASE ) , [value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]] , ) snake_case_ : Any = tokenizer.tokenize("I was born in 92000, and this is falsé." ) self.assertListEqual( _SCREAMING_SNAKE_CASE , [ 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", "é", ".", ] , ) snake_case_ : Tuple = tokenizer.convert_tokens_to_ids(_SCREAMING_SNAKE_CASE ) self.assertListEqual( _SCREAMING_SNAKE_CASE , [ value + tokenizer.fairseq_offset for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4] # ^ unk: 2 + 1 = 3 unk: 2 + 1 = 3 ^ ] , ) snake_case_ : List[Any] = tokenizer.convert_ids_to_tokens(_SCREAMING_SNAKE_CASE ) self.assertListEqual( _SCREAMING_SNAKE_CASE , [ SPIECE_UNDERLINE + "I", SPIECE_UNDERLINE + "was", SPIECE_UNDERLINE + "b", "or", "n", SPIECE_UNDERLINE + "in", SPIECE_UNDERLINE + "", "<unk>", "2", "0", "0", "0", ",", SPIECE_UNDERLINE + "and", SPIECE_UNDERLINE + "this", SPIECE_UNDERLINE + "is", SPIECE_UNDERLINE + "f", "al", "s", "<unk>", ".", ] , ) def _lowerCAmelCase ( self ) -> List[str]: 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 snake_case_ : Tuple = (self.rust_tokenizer_class, "hf-internal-testing/tiny-xlm-roberta", {}) for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})''' ): snake_case_ : Optional[int] = self.rust_tokenizer_class.from_pretrained(_SCREAMING_SNAKE_CASE , **_SCREAMING_SNAKE_CASE ) snake_case_ : Optional[int] = self.tokenizer_class.from_pretrained(_SCREAMING_SNAKE_CASE , **_SCREAMING_SNAKE_CASE ) snake_case_ : Dict = tempfile.mkdtemp() snake_case_ : Any = tokenizer_r.save_pretrained(_SCREAMING_SNAKE_CASE ) snake_case_ : Union[str, Any] = tokenizer_p.save_pretrained(_SCREAMING_SNAKE_CASE ) # 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 ) ) snake_case_ : Optional[Any] = tuple(f for f in tokenizer_r_files if "tokenizer.json" not in f ) self.assertSequenceEqual(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) # Checks everything loads correctly in the same way snake_case_ : Optional[int] = tokenizer_r.from_pretrained(_SCREAMING_SNAKE_CASE ) snake_case_ : Optional[Any] = tokenizer_p.from_pretrained(_SCREAMING_SNAKE_CASE ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) ) # self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key)) # self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id")) shutil.rmtree(_SCREAMING_SNAKE_CASE ) # Save tokenizer rust, legacy_format=True snake_case_ : Union[str, Any] = tempfile.mkdtemp() snake_case_ : Tuple = tokenizer_r.save_pretrained(_SCREAMING_SNAKE_CASE , legacy_format=_SCREAMING_SNAKE_CASE ) snake_case_ : Optional[Any] = tokenizer_p.save_pretrained(_SCREAMING_SNAKE_CASE ) # Checks it save with the same files self.assertSequenceEqual(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) # Checks everything loads correctly in the same way snake_case_ : int = tokenizer_r.from_pretrained(_SCREAMING_SNAKE_CASE ) snake_case_ : List[Any] = tokenizer_p.from_pretrained(_SCREAMING_SNAKE_CASE ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) ) shutil.rmtree(_SCREAMING_SNAKE_CASE ) # Save tokenizer rust, legacy_format=False snake_case_ : Union[str, Any] = tempfile.mkdtemp() snake_case_ : Dict = tokenizer_r.save_pretrained(_SCREAMING_SNAKE_CASE , legacy_format=_SCREAMING_SNAKE_CASE ) snake_case_ : Union[str, Any] = tokenizer_p.save_pretrained(_SCREAMING_SNAKE_CASE ) # 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 snake_case_ : List[Any] = tokenizer_r.from_pretrained(_SCREAMING_SNAKE_CASE ) snake_case_ : Dict = tokenizer_p.from_pretrained(_SCREAMING_SNAKE_CASE ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) ) shutil.rmtree(_SCREAMING_SNAKE_CASE ) @cached_property def _lowerCAmelCase ( self ) -> Optional[Any]: return XLMRobertaTokenizer.from_pretrained("xlm-roberta-base" ) def _lowerCAmelCase ( self ) -> Optional[int]: with tempfile.NamedTemporaryFile() as f: shutil.copyfile(_SCREAMING_SNAKE_CASE , f.name ) snake_case_ : Any = XLMRobertaTokenizer(f.name , keep_accents=_SCREAMING_SNAKE_CASE ) snake_case_ : Any = pickle.dumps(_SCREAMING_SNAKE_CASE ) pickle.loads(_SCREAMING_SNAKE_CASE ) def _lowerCAmelCase ( self ) -> Optional[int]: if not self.test_rust_tokenizer: return snake_case_ : Optional[int] = self.get_tokenizer() snake_case_ : List[Any] = self.get_rust_tokenizer() snake_case_ : str = "I was born in 92000, and this is falsé." snake_case_ : List[Any] = tokenizer.tokenize(_SCREAMING_SNAKE_CASE ) snake_case_ : Tuple = rust_tokenizer.tokenize(_SCREAMING_SNAKE_CASE ) self.assertListEqual(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) snake_case_ : Any = tokenizer.encode(_SCREAMING_SNAKE_CASE , add_special_tokens=_SCREAMING_SNAKE_CASE ) snake_case_ : str = rust_tokenizer.encode(_SCREAMING_SNAKE_CASE , add_special_tokens=_SCREAMING_SNAKE_CASE ) self.assertListEqual(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) snake_case_ : str = self.get_rust_tokenizer() snake_case_ : Union[str, Any] = tokenizer.encode(_SCREAMING_SNAKE_CASE ) snake_case_ : int = rust_tokenizer.encode(_SCREAMING_SNAKE_CASE ) self.assertListEqual(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) @slow def _lowerCAmelCase ( self ) -> Dict: snake_case_ : Union[str, Any] = "Hello World!" snake_case_ : int = [0, 3_5378, 6661, 38, 2] # xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.base') # xlmr.large has same tokenizer # xlmr.eval() # xlmr.encode(symbols) self.assertListEqual(_SCREAMING_SNAKE_CASE , self.big_tokenizer.encode(_SCREAMING_SNAKE_CASE ) ) @slow def _lowerCAmelCase ( self ) -> Optional[Any]: snake_case_ : Optional[int] = ( "This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) \" [ ] ! : - . Also we will" " add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth" ) snake_case_ : Tuple = [ 0, 3293, 83, 10, 4552, 4989, 7986, 678, 10, 5915, 111, 17_9459, 12_4850, 4, 6044, 237, 12, 6, 5, 6, 4, 6780, 705, 15, 1388, 44, 378, 1_0114, 711, 152, 20, 6, 5, 2_2376, 642, 1221, 1_5190, 3_4153, 450, 5608, 959, 1119, 5_7702, 136, 186, 47, 1098, 2_9367, 47, # 4426, # What fairseq tokenizes from "<unk>": "_<" # 3678, # What fairseq tokenizes from "<unk>": "unk" # 2740, # What fairseq tokenizes from "<unk>": ">" 3, # What we tokenize from "<unk>": "<unk>" 6, # Residue from the tokenization: an extra sentencepiece underline 4, 6044, 237, 6284, 5_0901, 528, 31, 90, 34, 927, 2, ] # xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.base') # xlmr.large has same tokenizer # xlmr.eval() # xlmr.encode(symbols) self.assertListEqual(_SCREAMING_SNAKE_CASE , self.big_tokenizer.encode(_SCREAMING_SNAKE_CASE ) ) @slow def _lowerCAmelCase ( self ) -> Dict: # fmt: off snake_case_ : List[Any] = {"input_ids": [[0, 1_1062, 8_2772, 7, 15, 8_2772, 538, 5_1529, 237, 1_7198, 1290, 206, 9, 21_5175, 1314, 136, 1_7198, 1290, 206, 9, 5_6359, 42, 12_2009, 9, 1_6466, 16, 8_7344, 4537, 9, 4717, 7_8381, 6, 15_9958, 7, 15, 2_4480, 618, 4, 527, 2_2693, 5428, 4, 2777, 2_4480, 9874, 4, 4_3523, 594, 4, 803, 1_8392, 3_3189, 18, 4, 4_3523, 2_4447, 1_2399, 100, 2_4955, 8_3658, 9626, 14_4057, 15, 839, 2_2335, 16, 136, 2_4955, 8_3658, 8_3479, 15, 3_9102, 724, 16, 678, 645, 2789, 1328, 4589, 42, 12_2009, 11_5774, 23, 805, 1328, 4_6876, 7, 136, 5_3894, 1940, 4_2227, 4_1159, 1_7721, 823, 425, 4, 2_7512, 9_8722, 206, 136, 5531, 4970, 919, 1_7336, 5, 2], [0, 2_0080, 618, 83, 8_2775, 47, 479, 9, 1517, 73, 5_3894, 333, 8_0581, 11_0117, 1_8811, 5256, 1295, 51, 15_2526, 297, 7986, 390, 12_4416, 538, 3_5431, 214, 98, 1_5044, 2_5737, 136, 7108, 4_3701, 23, 756, 13_5355, 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], [0, 581, 6_3773, 11_9455, 6, 14_7797, 8_8203, 7, 645, 70, 21, 3285, 1_0269, 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=_SCREAMING_SNAKE_CASE , model_name="xlm-roberta-base" , revision="d9d8a8ea5eb94b1c6654ae9249df7793cd2933d3" , )
36
import os import tempfile import unittest from pathlib import Path from transformers import AutoConfig, is_tf_available from transformers.testing_utils import require_tf if is_tf_available(): import tensorflow as tf from transformers import TensorFlowBenchmark, TensorFlowBenchmarkArguments @require_tf class UpperCAmelCase_ ( unittest.TestCase ): '''simple docstring''' def _lowerCAmelCase ( self , _SCREAMING_SNAKE_CASE ) -> int: for model_result in results.values(): for batch_size, sequence_length in zip(model_result["bs"] , model_result["ss"] ): snake_case_ : List[Any] = model_result["result"][batch_size][sequence_length] self.assertIsNotNone(_SCREAMING_SNAKE_CASE ) def _lowerCAmelCase ( self ) -> Tuple: snake_case_ : Dict = "sshleifer/tiny-gpt2" snake_case_ : Optional[Any] = TensorFlowBenchmarkArguments( models=[MODEL_ID] , training=_SCREAMING_SNAKE_CASE , inference=_SCREAMING_SNAKE_CASE , sequence_lengths=[8] , batch_sizes=[1] , eager_mode=_SCREAMING_SNAKE_CASE , multi_process=_SCREAMING_SNAKE_CASE , ) snake_case_ : Optional[Any] = TensorFlowBenchmark(_SCREAMING_SNAKE_CASE ) snake_case_ : Optional[Any] = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def _lowerCAmelCase ( self ) -> int: snake_case_ : List[Any] = "sgugger/tiny-distilbert-classification" snake_case_ : Optional[Any] = TensorFlowBenchmarkArguments( models=[MODEL_ID] , training=_SCREAMING_SNAKE_CASE , inference=_SCREAMING_SNAKE_CASE , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_SCREAMING_SNAKE_CASE , only_pretrain_model=_SCREAMING_SNAKE_CASE , ) snake_case_ : int = TensorFlowBenchmark(_SCREAMING_SNAKE_CASE ) snake_case_ : Union[str, Any] = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def _lowerCAmelCase ( self ) -> Tuple: snake_case_ : List[str] = "sshleifer/tiny-gpt2" snake_case_ : Optional[Any] = TensorFlowBenchmarkArguments( models=[MODEL_ID] , training=_SCREAMING_SNAKE_CASE , inference=_SCREAMING_SNAKE_CASE , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_SCREAMING_SNAKE_CASE , ) snake_case_ : Optional[Any] = TensorFlowBenchmark(_SCREAMING_SNAKE_CASE ) snake_case_ : int = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def _lowerCAmelCase ( self ) -> int: snake_case_ : Union[str, Any] = "sshleifer/tiny-gpt2" snake_case_ : List[str] = AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE ) snake_case_ : int = TensorFlowBenchmarkArguments( models=[MODEL_ID] , training=_SCREAMING_SNAKE_CASE , inference=_SCREAMING_SNAKE_CASE , sequence_lengths=[8] , batch_sizes=[1] , eager_mode=_SCREAMING_SNAKE_CASE , multi_process=_SCREAMING_SNAKE_CASE , ) snake_case_ : List[str] = TensorFlowBenchmark(_SCREAMING_SNAKE_CASE , [config] ) snake_case_ : Optional[int] = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def _lowerCAmelCase ( self ) -> List[str]: snake_case_ : str = "sshleifer/tiny-gpt2" snake_case_ : int = AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE ) snake_case_ : Dict = TensorFlowBenchmarkArguments( models=[MODEL_ID] , training=_SCREAMING_SNAKE_CASE , inference=_SCREAMING_SNAKE_CASE , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_SCREAMING_SNAKE_CASE , ) snake_case_ : List[Any] = TensorFlowBenchmark(_SCREAMING_SNAKE_CASE , [config] ) snake_case_ : Union[str, Any] = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def _lowerCAmelCase ( self ) -> str: snake_case_ : List[str] = "sshleifer/tiny-gpt2" snake_case_ : Tuple = TensorFlowBenchmarkArguments( models=[MODEL_ID] , training=_SCREAMING_SNAKE_CASE , inference=_SCREAMING_SNAKE_CASE , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_SCREAMING_SNAKE_CASE , ) snake_case_ : List[str] = TensorFlowBenchmark(_SCREAMING_SNAKE_CASE ) snake_case_ : Dict = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) def _lowerCAmelCase ( self ) -> Dict: snake_case_ : str = "sshleifer/tiny-gpt2" snake_case_ : str = AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE ) snake_case_ : Dict = TensorFlowBenchmarkArguments( models=[MODEL_ID] , training=_SCREAMING_SNAKE_CASE , inference=_SCREAMING_SNAKE_CASE , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_SCREAMING_SNAKE_CASE , ) snake_case_ : Optional[Any] = TensorFlowBenchmark(_SCREAMING_SNAKE_CASE , [config] ) snake_case_ : str = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) def _lowerCAmelCase ( self ) -> List[str]: snake_case_ : List[str] = "patrickvonplaten/t5-tiny-random" snake_case_ : Union[str, Any] = AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE ) snake_case_ : Optional[Any] = TensorFlowBenchmarkArguments( models=[MODEL_ID] , training=_SCREAMING_SNAKE_CASE , inference=_SCREAMING_SNAKE_CASE , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_SCREAMING_SNAKE_CASE , ) snake_case_ : List[str] = TensorFlowBenchmark(_SCREAMING_SNAKE_CASE , configs=[config] ) snake_case_ : List[Any] = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) @unittest.skipIf(is_tf_available() and len(tf.config.list_physical_devices("GPU" ) ) == 0 , "Cannot do xla on CPU." ) def _lowerCAmelCase ( self ) -> Dict: snake_case_ : int = "sshleifer/tiny-gpt2" snake_case_ : Tuple = TensorFlowBenchmarkArguments( models=[MODEL_ID] , training=_SCREAMING_SNAKE_CASE , inference=_SCREAMING_SNAKE_CASE , sequence_lengths=[8] , batch_sizes=[1] , use_xla=_SCREAMING_SNAKE_CASE , multi_process=_SCREAMING_SNAKE_CASE , ) snake_case_ : List[str] = TensorFlowBenchmark(_SCREAMING_SNAKE_CASE ) snake_case_ : str = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def _lowerCAmelCase ( self ) -> Tuple: snake_case_ : Union[str, Any] = "sshleifer/tiny-gpt2" with tempfile.TemporaryDirectory() as tmp_dir: snake_case_ : Optional[int] = TensorFlowBenchmarkArguments( models=[MODEL_ID] , inference=_SCREAMING_SNAKE_CASE , save_to_csv=_SCREAMING_SNAKE_CASE , sequence_lengths=[8] , batch_sizes=[1] , inference_time_csv_file=os.path.join(_SCREAMING_SNAKE_CASE , "inf_time.csv" ) , inference_memory_csv_file=os.path.join(_SCREAMING_SNAKE_CASE , "inf_mem.csv" ) , env_info_csv_file=os.path.join(_SCREAMING_SNAKE_CASE , "env.csv" ) , multi_process=_SCREAMING_SNAKE_CASE , ) snake_case_ : Dict = TensorFlowBenchmark(_SCREAMING_SNAKE_CASE ) benchmark.run() self.assertTrue(Path(os.path.join(_SCREAMING_SNAKE_CASE , "inf_time.csv" ) ).exists() ) self.assertTrue(Path(os.path.join(_SCREAMING_SNAKE_CASE , "inf_mem.csv" ) ).exists() ) self.assertTrue(Path(os.path.join(_SCREAMING_SNAKE_CASE , "env.csv" ) ).exists() ) def _lowerCAmelCase ( self ) -> List[str]: snake_case_ : int = "sshleifer/tiny-gpt2" def _check_summary_is_not_empty(_SCREAMING_SNAKE_CASE ): self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE , "sequential" ) ) self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE , "cumulative" ) ) self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE , "current" ) ) self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE , "total" ) ) with tempfile.TemporaryDirectory() as tmp_dir: snake_case_ : Union[str, Any] = TensorFlowBenchmarkArguments( models=[MODEL_ID] , inference=_SCREAMING_SNAKE_CASE , sequence_lengths=[8] , batch_sizes=[1] , log_filename=os.path.join(_SCREAMING_SNAKE_CASE , "log.txt" ) , log_print=_SCREAMING_SNAKE_CASE , trace_memory_line_by_line=_SCREAMING_SNAKE_CASE , eager_mode=_SCREAMING_SNAKE_CASE , multi_process=_SCREAMING_SNAKE_CASE , ) snake_case_ : Tuple = TensorFlowBenchmark(_SCREAMING_SNAKE_CASE ) snake_case_ : int = benchmark.run() _check_summary_is_not_empty(result.inference_summary ) self.assertTrue(Path(os.path.join(_SCREAMING_SNAKE_CASE , "log.txt" ) ).exists() )
36
1
from ...configuration_utils import PretrainedConfig from ...utils import logging lowerCAmelCase__ : Union[str, Any] =logging.get_logger(__name__) lowerCAmelCase__ : Tuple ={ '''microsoft/cvt-13''': '''https://huggingface.co/microsoft/cvt-13/resolve/main/config.json''', # See all Cvt models at https://huggingface.co/models?filter=cvt } class UpperCAmelCase_ ( UpperCamelCase_ ): '''simple docstring''' UpperCamelCase__ : Union[str, Any] = '''cvt''' def __init__( self , _A=3 , _A=[7, 3, 3] , _A=[4, 2, 2] , _A=[2, 1, 1] , _A=[64, 192, 384] , _A=[1, 3, 6] , _A=[1, 2, 10] , _A=[4.0, 4.0, 4.0] , _A=[0.0, 0.0, 0.0] , _A=[0.0, 0.0, 0.0] , _A=[0.0, 0.0, 0.1] , _A=[True, True, True] , _A=[False, False, True] , _A=["dw_bn", "dw_bn", "dw_bn"] , _A=[3, 3, 3] , _A=[1, 1, 1] , _A=[2, 2, 2] , _A=[1, 1, 1] , _A=[1, 1, 1] , _A=0.0_2 , _A=1e-12 , **_A , ): '''simple docstring''' super().__init__(**_A ) __SCREAMING_SNAKE_CASE = num_channels __SCREAMING_SNAKE_CASE = patch_sizes __SCREAMING_SNAKE_CASE = patch_stride __SCREAMING_SNAKE_CASE = patch_padding __SCREAMING_SNAKE_CASE = embed_dim __SCREAMING_SNAKE_CASE = num_heads __SCREAMING_SNAKE_CASE = depth __SCREAMING_SNAKE_CASE = mlp_ratio __SCREAMING_SNAKE_CASE = attention_drop_rate __SCREAMING_SNAKE_CASE = drop_rate __SCREAMING_SNAKE_CASE = drop_path_rate __SCREAMING_SNAKE_CASE = qkv_bias __SCREAMING_SNAKE_CASE = cls_token __SCREAMING_SNAKE_CASE = qkv_projection_method __SCREAMING_SNAKE_CASE = kernel_qkv __SCREAMING_SNAKE_CASE = padding_kv __SCREAMING_SNAKE_CASE = stride_kv __SCREAMING_SNAKE_CASE = padding_q __SCREAMING_SNAKE_CASE = stride_q __SCREAMING_SNAKE_CASE = initializer_range __SCREAMING_SNAKE_CASE = layer_norm_eps
257
def __lowercase ( a__ , a__ ) -> bool: return numa ^ numa < 0 if __name__ == "__main__": import doctest doctest.testmod()
257
1
from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging snake_case : Dict = logging.get_logger(__name__) snake_case : List[str] = { '''google/bigbird-roberta-base''': '''https://huggingface.co/google/bigbird-roberta-base/resolve/main/config.json''', '''google/bigbird-roberta-large''': '''https://huggingface.co/google/bigbird-roberta-large/resolve/main/config.json''', '''google/bigbird-base-trivia-itc''': '''https://huggingface.co/google/bigbird-base-trivia-itc/resolve/main/config.json''', # See all BigBird models at https://huggingface.co/models?filter=big_bird } class _snake_case ( _snake_case ): SCREAMING_SNAKE_CASE__ = 'big_bird' def __init__( self , _lowerCamelCase=5_0358 , _lowerCamelCase=768 , _lowerCamelCase=12 , _lowerCamelCase=12 , _lowerCamelCase=3072 , _lowerCamelCase="gelu_new" , _lowerCamelCase=0.1 , _lowerCamelCase=0.1 , _lowerCamelCase=4096 , _lowerCamelCase=2 , _lowerCamelCase=0.02 , _lowerCamelCase=1e-12 , _lowerCamelCase=True , _lowerCamelCase=0 , _lowerCamelCase=1 , _lowerCamelCase=2 , _lowerCamelCase=66 , _lowerCamelCase="block_sparse" , _lowerCamelCase=True , _lowerCamelCase=False , _lowerCamelCase=64 , _lowerCamelCase=3 , _lowerCamelCase=None , **_lowerCamelCase , ): super().__init__( pad_token_id=_lowerCamelCase , bos_token_id=_lowerCamelCase , eos_token_id=_lowerCamelCase , sep_token_id=_lowerCamelCase , **_lowerCamelCase , ) a :str = vocab_size a :List[str] = max_position_embeddings a :List[str] = hidden_size a :str = num_hidden_layers a :List[str] = num_attention_heads a :List[Any] = intermediate_size a :Any = hidden_act a :Any = hidden_dropout_prob a :str = attention_probs_dropout_prob a :Union[str, Any] = initializer_range a :str = type_vocab_size a :Optional[Any] = layer_norm_eps a :Optional[int] = use_cache a :int = rescale_embeddings a :str = attention_type a :List[Any] = use_bias a :int = block_size a :str = num_random_blocks a :Dict = classifier_dropout class _snake_case ( _snake_case ): @property def SCREAMING_SNAKE_CASE__ ( self ): if self.task == "multiple-choice": a :List[str] = {0: '''batch''', 1: '''choice''', 2: '''sequence'''} else: a :Any = {0: '''batch''', 1: '''sequence'''} return OrderedDict( [ ('''input_ids''', dynamic_axis), ('''attention_mask''', dynamic_axis), ] )
281
import os import unittest from transformers.models.bartpho.tokenization_bartpho import VOCAB_FILES_NAMES, BartphoTokenizer from transformers.testing_utils import get_tests_dir from ...test_tokenization_common import TokenizerTesterMixin snake_case : List[Any] = get_tests_dir('''fixtures/test_sentencepiece_bpe.model''') class _snake_case ( _snake_case , unittest.TestCase ): SCREAMING_SNAKE_CASE__ = BartphoTokenizer SCREAMING_SNAKE_CASE__ = False SCREAMING_SNAKE_CASE__ = True def SCREAMING_SNAKE_CASE__ ( self ): super().setUp() a :Dict = ['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est'''] a :Optional[Any] = dict(zip(_lowerCamelCase , range(len(_lowerCamelCase ) ) ) ) a :Tuple = {'''unk_token''': '''<unk>'''} a :Union[str, Any] = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['''monolingual_vocab_file'''] ) with open(self.monolingual_vocab_file , '''w''' , encoding='''utf-8''' ) as fp: for token in vocab_tokens: fp.write(F'''{token} {vocab_tokens[token]}\n''' ) a :Any = BartphoTokenizer(_lowerCamelCase , self.monolingual_vocab_file , **self.special_tokens_map ) tokenizer.save_pretrained(self.tmpdirname ) def SCREAMING_SNAKE_CASE__ ( self , **_lowerCamelCase ): kwargs.update(self.special_tokens_map ) return BartphoTokenizer.from_pretrained(self.tmpdirname , **_lowerCamelCase ) def SCREAMING_SNAKE_CASE__ ( self , _lowerCamelCase ): a :int = '''This is a là test''' a :str = '''This is a<unk><unk> test''' return input_text, output_text def SCREAMING_SNAKE_CASE__ ( self ): a :List[str] = BartphoTokenizer(_lowerCamelCase , self.monolingual_vocab_file , **self.special_tokens_map ) a :Optional[Any] = '''This is a là test''' a :Tuple = '''▁This ▁is ▁a ▁l à ▁t est'''.split() a :int = tokenizer.tokenize(_lowerCamelCase ) self.assertListEqual(_lowerCamelCase , _lowerCamelCase ) a :Union[str, Any] = tokens + [tokenizer.unk_token] a :str = [4, 5, 6, 3, 3, 7, 8, 3] self.assertListEqual(tokenizer.convert_tokens_to_ids(_lowerCamelCase ) , _lowerCamelCase )
281
1
from manim import * class UpperCamelCase__ ( __SCREAMING_SNAKE_CASE ): '''simple docstring''' def SCREAMING_SNAKE_CASE__ ( self : List[str] ) -> Optional[int]: '''simple docstring''' SCREAMING_SNAKE_CASE = Rectangle(height=0.5 ,width=0.5 ) SCREAMING_SNAKE_CASE = Rectangle(height=0.46 ,width=0.46 ).set_stroke(width=0 ) SCREAMING_SNAKE_CASE = [mem.copy() for i in range(6 )] SCREAMING_SNAKE_CASE = [mem.copy() for i in range(6 )] SCREAMING_SNAKE_CASE = VGroup(*lowerCamelCase__ ).arrange(lowerCamelCase__ ,buff=0 ) SCREAMING_SNAKE_CASE = VGroup(*lowerCamelCase__ ).arrange(lowerCamelCase__ ,buff=0 ) SCREAMING_SNAKE_CASE = VGroup(lowerCamelCase__ ,lowerCamelCase__ ).arrange(lowerCamelCase__ ,buff=0 ) SCREAMING_SNAKE_CASE = Text("""CPU""" ,font_size=24 ) SCREAMING_SNAKE_CASE = Group(lowerCamelCase__ ,lowerCamelCase__ ).arrange(lowerCamelCase__ ,buff=0.5 ,aligned_edge=lowerCamelCase__ ) cpu.move_to([-2.5, -0.5, 0] ) self.add(lowerCamelCase__ ) SCREAMING_SNAKE_CASE = [mem.copy() for i in range(1 )] SCREAMING_SNAKE_CASE = VGroup(*lowerCamelCase__ ).arrange(lowerCamelCase__ ,buff=0 ) SCREAMING_SNAKE_CASE = Text("""GPU""" ,font_size=24 ) SCREAMING_SNAKE_CASE = Group(lowerCamelCase__ ,lowerCamelCase__ ).arrange(lowerCamelCase__ ,buff=0.5 ,aligned_edge=lowerCamelCase__ ) gpu.align_to(lowerCamelCase__ ,lowerCamelCase__ ) gpu.set_x(gpu.get_x() - 1 ) self.add(lowerCamelCase__ ) SCREAMING_SNAKE_CASE = [mem.copy() for i in range(6 )] SCREAMING_SNAKE_CASE = VGroup(*lowerCamelCase__ ).arrange(lowerCamelCase__ ,buff=0 ) SCREAMING_SNAKE_CASE = Text("""Model""" ,font_size=24 ) SCREAMING_SNAKE_CASE = Group(lowerCamelCase__ ,lowerCamelCase__ ).arrange(lowerCamelCase__ ,buff=0.5 ,aligned_edge=lowerCamelCase__ ) model.move_to([3, -1.0, 0] ) self.play( Create(lowerCamelCase__ ,run_time=1 ) ,Create(lowerCamelCase__ ,run_time=1 ) ,Create(lowerCamelCase__ ,run_time=1 ) ,) SCREAMING_SNAKE_CASE = MarkupText( F"""First, an empty model skeleton is loaded\ninto <span fgcolor=\'{YELLOW}\'>memory</span> without using much RAM.""" ,font_size=24 ,) SCREAMING_SNAKE_CASE = Square(side_length=2.2 ) key.move_to([-5, 2, 0] ) SCREAMING_SNAKE_CASE = MarkupText( F"""<b>Key:</b>\n\n<span fgcolor=\'{YELLOW}\'>●</span> Empty Model""" ,font_size=18 ,) key_text.move_to([-5, 2.4, 0] ) step_a.move_to([2, 2, 0] ) self.play(Write(lowerCamelCase__ ,run_time=2.5 ) ,Write(lowerCamelCase__ ) ,Write(lowerCamelCase__ ) ) self.add(lowerCamelCase__ ) SCREAMING_SNAKE_CASE = [] SCREAMING_SNAKE_CASE = [] SCREAMING_SNAKE_CASE = [] for i, rect in enumerate(lowerCamelCase__ ): SCREAMING_SNAKE_CASE = Rectangle(height=0.46 ,width=0.46 ).set_stroke(width=0.0 ).set_fill(lowerCamelCase__ ,opacity=0.7 ) cpu_target.move_to(lowerCamelCase__ ) cpu_target.generate_target() SCREAMING_SNAKE_CASE = 0.46 / 4 SCREAMING_SNAKE_CASE = 0.46 / 3 if i == 0: cpu_target.target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT ) ,buff=0.02 ,direction=lowerCamelCase__ ) cpu_target.target.set_x(cpu_target.target.get_x() + 0.1 ) elif i == 3: cpu_target.target.next_to(cpu_targs[0].target ,direction=lowerCamelCase__ ,buff=0.0 ) else: cpu_target.target.next_to(cpu_targs[i - 1].target ,direction=lowerCamelCase__ ,buff=0.0 ) cpu_targs.append(lowerCamelCase__ ) first_animations.append(rect.animate(run_time=0.5 ).set_stroke(lowerCamelCase__ ) ) second_animations.append(MoveToTarget(lowerCamelCase__ ,run_time=1.5 ) ) self.play(*lowerCamelCase__ ) self.play(*lowerCamelCase__ ) self.wait()
296
import json import sys def _a ( lowerCamelCase, lowerCamelCase ): with open(lowerCamelCase, encoding="""utf-8""" ) as f: lowerCamelCase : List[Any] = json.load(lowerCamelCase ) lowerCamelCase : Optional[Any] = ["""<details>""", """<summary>Show updated benchmarks!</summary>""", """ """] for benchmark_name in sorted(lowerCamelCase ): lowerCamelCase : List[Any] = results[benchmark_name] lowerCamelCase : Union[str, Any] = benchmark_name.split("""/""" )[-1] output_md.append(F'''### Benchmark: {benchmark_file_name}''' ) lowerCamelCase : Any = """| metric |""" lowerCamelCase : str = """|--------|""" lowerCamelCase : List[Any] = """| new / old (diff) |""" for metric_name in sorted(lowerCamelCase ): lowerCamelCase : List[Any] = benchmark_res[metric_name] lowerCamelCase : Tuple = metric_vals["""new"""] lowerCamelCase : int = metric_vals.get("""old""", lowerCamelCase ) lowerCamelCase : Dict = metric_vals.get("""diff""", lowerCamelCase ) lowerCamelCase : Dict = F''' {new_val:f}''' if isinstance(lowerCamelCase, (int, float) ) else """None""" if old_val is not None: val_str += F''' / {old_val:f}''' if isinstance(lowerCamelCase, (int, float) ) else "None" if dif_val is not None: val_str += F''' ({dif_val:f})''' if isinstance(lowerCamelCase, (int, float) ) else "None" title += " " + metric_name + " |" lines += "---|" value += val_str + " |" output_md += [title, lines, value, " "] output_md.append("""</details>""" ) with open(lowerCamelCase, """w""", encoding="""utf-8""" ) as f: f.writelines("""\n""".join(lowerCamelCase ) ) if __name__ == "__main__": _lowerCamelCase =sys.argv[1] _lowerCamelCase =sys.argv[2] format_json_to_md(input_json_file, output_md_file)
287
0
"""simple docstring""" from __future__ import annotations import pandas as pd def UpperCamelCase_ ( _lowerCAmelCase : list[int], _lowerCAmelCase : list[int], _lowerCAmelCase : int ): """simple docstring""" _a = [0] * no_of_processes _a = [0] * no_of_processes # Copy the burst time into remaining_time[] for i in range(_SCREAMING_SNAKE_CASE ): _a = burst_time[i] _a = 0 _a = 0 _a = 9_99_99_99_99 _a = 0 _a = False # Process until all processes are completed while complete != no_of_processes: for j in range(_SCREAMING_SNAKE_CASE ): if arrival_time[j] <= increment_time and remaining_time[j] > 0: if remaining_time[j] < minm: _a = remaining_time[j] _a = j _a = True if not check: increment_time += 1 continue remaining_time[short] -= 1 _a = remaining_time[short] if minm == 0: _a = 9_99_99_99_99 if remaining_time[short] == 0: complete += 1 _a = False # Find finish time of current process _a = increment_time + 1 # Calculate waiting time _a = finish_time - arrival_time[short] _a = finar - burst_time[short] if waiting_time[short] < 0: _a = 0 # Increment time increment_time += 1 return waiting_time def UpperCamelCase_ ( _lowerCAmelCase : list[int], _lowerCAmelCase : int, _lowerCAmelCase : list[int] ): """simple docstring""" _a = [0] * no_of_processes for i in range(_SCREAMING_SNAKE_CASE ): _a = burst_time[i] + waiting_time[i] return turn_around_time def UpperCamelCase_ ( _lowerCAmelCase : list[int], _lowerCAmelCase : list[int], _lowerCAmelCase : int ): """simple docstring""" _a = 0 _a = 0 for i in range(_SCREAMING_SNAKE_CASE ): _a = total_waiting_time + waiting_time[i] _a = total_turn_around_time + turn_around_time[i] print(f'Average waiting time = {total_waiting_time / no_of_processes:.5f}' ) print('''Average turn around time =''', total_turn_around_time / no_of_processes ) if __name__ == "__main__": print('''Enter how many process you want to analyze''') __snake_case = int(input()) __snake_case = [0] * no_of_processes __snake_case = [0] * no_of_processes __snake_case = list(range(1, no_of_processes + 1)) for i in range(no_of_processes): print('''Enter the arrival time and burst time for process:--''' + str(i + 1)) __snake_case ,__snake_case = map(int, input().split()) __snake_case = calculate_waitingtime(arrival_time, burst_time, no_of_processes) __snake_case = burst_time __snake_case = no_of_processes __snake_case = waiting_time __snake_case = calculate_turnaroundtime(bt, n, wt) calculate_average_times(waiting_time, turn_around_time, no_of_processes) __snake_case = pd.DataFrame( list(zip(processes, burst_time, arrival_time, waiting_time, turn_around_time)), columns=[ '''Process''', '''BurstTime''', '''ArrivalTime''', '''WaitingTime''', '''TurnAroundTime''', ], ) # Printing the dataFrame pd.set_option('''display.max_rows''', fcfs.shape[0] + 1) print(fcfs)
351
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, ) __snake_case = { '''configuration_resnet''': ['''RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ResNetConfig''', '''ResNetOnnxConfig'''] } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __snake_case = [ '''RESNET_PRETRAINED_MODEL_ARCHIVE_LIST''', '''ResNetForImageClassification''', '''ResNetModel''', '''ResNetPreTrainedModel''', '''ResNetBackbone''', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __snake_case = [ '''TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST''', '''TFResNetForImageClassification''', '''TFResNetModel''', '''TFResNetPreTrainedModel''', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __snake_case = [ '''FlaxResNetForImageClassification''', '''FlaxResNetModel''', '''FlaxResNetPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_resnet import RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP, ResNetConfig, ResNetOnnxConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_resnet import ( RESNET_PRETRAINED_MODEL_ARCHIVE_LIST, ResNetBackbone, ResNetForImageClassification, ResNetModel, ResNetPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_resnet import ( TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFResNetForImageClassification, TFResNetModel, TFResNetPreTrainedModel, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_resnet import FlaxResNetForImageClassification, FlaxResNetModel, FlaxResNetPreTrainedModel else: import sys __snake_case = _LazyModule(__name__, globals()['''__file__'''], _import_structure)
153
0
'''simple docstring''' from collections import Counter import numpy as np from sklearn import datasets from sklearn.model_selection import train_test_split __lowerCAmelCase : List[str] =datasets.load_iris() __lowerCAmelCase : str =np.array(data["data"]) __lowerCAmelCase : Any =np.array(data["target"]) __lowerCAmelCase : str =data["target_names"] __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase : str =train_test_split(X, y) def UpperCamelCase ( _lowerCamelCase : Tuple , _lowerCamelCase : Union[str, Any] ): return np.linalg.norm(np.array(_lowerCamelCase ) - np.array(_lowerCamelCase ) ) def UpperCamelCase ( _lowerCamelCase : Optional[int] , _lowerCamelCase : List[str] , _lowerCamelCase : int , _lowerCamelCase : Optional[Any] , _lowerCamelCase : Tuple=5 ): A__ = zip(_lowerCamelCase , _lowerCamelCase ) # List of distances of all points from the point to be classified A__ = [] for data_point in data: A__ = euclidean_distance(data_point[0] , _lowerCamelCase ) distances.append((distance, data_point[1]) ) # Choosing 'k' points with the least distances. A__ = [i[1] for i in sorted(_lowerCamelCase )[:k]] # Most commonly occurring class among them # is the class into which the point is classified A__ = Counter(_lowerCamelCase ).most_common(1 )[0][0] return classes[result] if __name__ == "__main__": print(classifier(X_train, y_train, classes, [4.4, 3.1, 1.3, 1.4]))
237
'''simple docstring''' import math import time from transformers import Trainer, is_torch_tpu_available from transformers.trainer_utils import PredictionOutput, speed_metrics if is_torch_tpu_available(check_device=False): import torch_xla.core.xla_model as xm import torch_xla.debug.metrics as met class UpperCAmelCase ( UpperCamelCase__ ): def __init__( self :Optional[Any] , *lowercase_ :int , lowercase_ :Any=None , lowercase_ :List[str]=None , **lowercase_ :Any )-> Any: super().__init__(*lowercase_ , **lowercase_ ) A__ = eval_examples A__ = post_process_function def UpperCAmelCase_ ( self :str , lowercase_ :str=None , lowercase_ :Optional[int]=None , lowercase_ :Optional[int]=None , lowercase_ :str = "eval" )-> Union[str, Any]: A__ = self.eval_dataset if eval_dataset is None else eval_dataset A__ = self.get_eval_dataloader(lowercase_ ) A__ = self.eval_examples if eval_examples is None else eval_examples # Temporarily disable metric computation, we will do it in the loop here. A__ = self.compute_metrics A__ = None A__ = self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop A__ = time.time() try: A__ = eval_loop( lowercase_ , description="Evaluation" , prediction_loss_only=True if compute_metrics is None else None , ignore_keys=lowercase_ , metric_key_prefix=lowercase_ , ) finally: A__ = compute_metrics A__ = self.args.eval_batch_size * self.args.world_size if F"{metric_key_prefix}_jit_compilation_time" in output.metrics: start_time += output.metrics[F"{metric_key_prefix}_jit_compilation_time"] output.metrics.update( speed_metrics( lowercase_ , lowercase_ , num_samples=output.num_samples , num_steps=math.ceil(output.num_samples / total_batch_size ) , ) ) if self.post_process_function is not None and self.compute_metrics is not None and self.args.should_save: # Only the main node write the results by default A__ = self.post_process_function(lowercase_ , lowercase_ , output.predictions ) A__ = self.compute_metrics(lowercase_ ) # Prefix all keys with metric_key_prefix + '_' for key in list(metrics.keys() ): if not key.startswith(F"{metric_key_prefix}_" ): A__ = metrics.pop(lowercase_ ) metrics.update(output.metrics ) else: A__ = output.metrics if self.args.should_log: # Only the main node log the results by default self.log(lowercase_ ) if self.args.tpu_metrics_debug or self.args.debug: # tpu-comment: Logging debug metrics for PyTorch/XLA (compile, execute times, ops, etc.) xm.master_print(met.metrics_report() ) A__ = self.callback_handler.on_evaluate(self.args , self.state , self.control , lowercase_ ) return metrics def UpperCAmelCase_ ( self :List[str] , lowercase_ :List[Any] , lowercase_ :str , lowercase_ :Any=None , lowercase_ :str = "test" )-> List[Any]: A__ = self.get_test_dataloader(lowercase_ ) # Temporarily disable metric computation, we will do it in the loop here. A__ = self.compute_metrics A__ = None A__ = self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop A__ = time.time() try: A__ = eval_loop( lowercase_ , description="Prediction" , prediction_loss_only=True if compute_metrics is None else None , ignore_keys=lowercase_ , metric_key_prefix=lowercase_ , ) finally: A__ = compute_metrics A__ = self.args.eval_batch_size * self.args.world_size if F"{metric_key_prefix}_jit_compilation_time" in output.metrics: start_time += output.metrics[F"{metric_key_prefix}_jit_compilation_time"] output.metrics.update( speed_metrics( lowercase_ , lowercase_ , num_samples=output.num_samples , num_steps=math.ceil(output.num_samples / total_batch_size ) , ) ) if self.post_process_function is None or self.compute_metrics is None: return output A__ = self.post_process_function(lowercase_ , lowercase_ , output.predictions , "predict" ) A__ = self.compute_metrics(lowercase_ ) # Prefix all keys with metric_key_prefix + '_' for key in list(metrics.keys() ): if not key.startswith(F"{metric_key_prefix}_" ): A__ = metrics.pop(lowercase_ ) metrics.update(output.metrics ) return PredictionOutput(predictions=predictions.predictions , label_ids=predictions.label_ids , metrics=lowercase_ )
237
1
"""simple docstring""" import argparse import json import requests import timm import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import AutoImageProcessor, SwinConfig, SwinForImageClassification def __SCREAMING_SNAKE_CASE ( A_ ): lowerCAmelCase__ : Dict = SwinConfig() lowerCAmelCase__ : List[str] = swin_name.split('''_''' ) lowerCAmelCase__ : List[Any] = name_split[1] lowerCAmelCase__ : Optional[int] = int(name_split[4] ) lowerCAmelCase__ : Any = int(name_split[3][-1] ) if model_size == "tiny": lowerCAmelCase__ : Tuple = 96 lowerCAmelCase__ : str = (2, 2, 6, 2) lowerCAmelCase__ : Tuple = (3, 6, 12, 24) elif model_size == "small": lowerCAmelCase__ : Any = 96 lowerCAmelCase__ : Dict = (2, 2, 18, 2) lowerCAmelCase__ : Optional[Any] = (3, 6, 12, 24) elif model_size == "base": lowerCAmelCase__ : Tuple = 1_28 lowerCAmelCase__ : List[str] = (2, 2, 18, 2) lowerCAmelCase__ : Optional[Any] = (4, 8, 16, 32) else: lowerCAmelCase__ : Optional[int] = 1_92 lowerCAmelCase__ : Optional[int] = (2, 2, 18, 2) lowerCAmelCase__ : Dict = (6, 12, 24, 48) if "in22k" in swin_name: lowerCAmelCase__ : List[str] = 2_18_41 else: lowerCAmelCase__ : Dict = 10_00 lowerCAmelCase__ : Optional[Any] = '''huggingface/label-files''' lowerCAmelCase__ : Any = '''imagenet-1k-id2label.json''' lowerCAmelCase__ : Optional[Any] = json.load(open(hf_hub_download(A_ , A_ , repo_type='''dataset''' ) , '''r''' ) ) lowerCAmelCase__ : Any = {int(A_ ): v for k, v in idalabel.items()} lowerCAmelCase__ : str = idalabel lowerCAmelCase__ : List[str] = {v: k for k, v in idalabel.items()} lowerCAmelCase__ : Dict = img_size lowerCAmelCase__ : str = num_classes lowerCAmelCase__ : Union[str, Any] = embed_dim lowerCAmelCase__ : Any = depths lowerCAmelCase__ : Optional[Any] = num_heads lowerCAmelCase__ : int = window_size return config def __SCREAMING_SNAKE_CASE ( A_ ): if "patch_embed.proj" in name: lowerCAmelCase__ : str = name.replace('''patch_embed.proj''' , '''embeddings.patch_embeddings.projection''' ) if "patch_embed.norm" in name: lowerCAmelCase__ : str = name.replace('''patch_embed.norm''' , '''embeddings.norm''' ) if "layers" in name: lowerCAmelCase__ : Any = '''encoder.''' + name if "attn.proj" in name: lowerCAmelCase__ : List[str] = name.replace('''attn.proj''' , '''attention.output.dense''' ) if "attn" in name: lowerCAmelCase__ : str = name.replace('''attn''' , '''attention.self''' ) if "norm1" in name: lowerCAmelCase__ : Tuple = name.replace('''norm1''' , '''layernorm_before''' ) if "norm2" in name: lowerCAmelCase__ : Tuple = name.replace('''norm2''' , '''layernorm_after''' ) if "mlp.fc1" in name: lowerCAmelCase__ : int = name.replace('''mlp.fc1''' , '''intermediate.dense''' ) if "mlp.fc2" in name: lowerCAmelCase__ : Dict = name.replace('''mlp.fc2''' , '''output.dense''' ) if name == "norm.weight": lowerCAmelCase__ : Optional[Any] = '''layernorm.weight''' if name == "norm.bias": lowerCAmelCase__ : str = '''layernorm.bias''' if "head" in name: lowerCAmelCase__ : List[str] = name.replace('''head''' , '''classifier''' ) else: lowerCAmelCase__ : List[Any] = '''swin.''' + name return name def __SCREAMING_SNAKE_CASE ( A_ , A_ ): for key in orig_state_dict.copy().keys(): lowerCAmelCase__ : Any = orig_state_dict.pop(A_ ) if "mask" in key: continue elif "qkv" in key: lowerCAmelCase__ : List[Any] = key.split('''.''' ) lowerCAmelCase__ : List[str] = int(key_split[1] ) lowerCAmelCase__ : Optional[Any] = int(key_split[3] ) lowerCAmelCase__ : Union[str, Any] = model.swin.encoder.layers[layer_num].blocks[block_num].attention.self.all_head_size if "weight" in key: lowerCAmelCase__ : Union[str, Any] = val[:dim, :] lowerCAmelCase__ : Optional[Any] = val[ dim : dim * 2, : ] lowerCAmelCase__ : Any = val[-dim:, :] else: lowerCAmelCase__ : int = val[ :dim ] lowerCAmelCase__ : Any = val[ dim : dim * 2 ] lowerCAmelCase__ : Union[str, Any] = val[ -dim: ] else: lowerCAmelCase__ : Dict = val return orig_state_dict def __SCREAMING_SNAKE_CASE ( A_ , A_ ): lowerCAmelCase__ : int = timm.create_model(A_ , pretrained=A_ ) timm_model.eval() lowerCAmelCase__ : Tuple = get_swin_config(A_ ) lowerCAmelCase__ : str = SwinForImageClassification(A_ ) model.eval() lowerCAmelCase__ : List[Any] = convert_state_dict(timm_model.state_dict() , A_ ) model.load_state_dict(A_ ) lowerCAmelCase__ : Tuple = '''http://images.cocodataset.org/val2017/000000039769.jpg''' lowerCAmelCase__ : Any = AutoImageProcessor.from_pretrained('''microsoft/{}'''.format(swin_name.replace('''_''' , '''-''' ) ) ) lowerCAmelCase__ : str = Image.open(requests.get(A_ , stream=A_ ).raw ) lowerCAmelCase__ : Any = image_processor(images=A_ , return_tensors='''pt''' ) lowerCAmelCase__ : str = timm_model(inputs['''pixel_values'''] ) lowerCAmelCase__ : Any = model(**A_ ).logits assert torch.allclose(A_ , A_ , atol=1e-3 ) print(f'Saving model {swin_name} to {pytorch_dump_folder_path}' ) model.save_pretrained(A_ ) print(f'Saving image processor to {pytorch_dump_folder_path}' ) image_processor.save_pretrained(A_ ) if __name__ == "__main__": __UpperCamelCase : Union[str, Any] = argparse.ArgumentParser() # Required parameters parser.add_argument( '''--swin_name''', default='''swin_tiny_patch4_window7_224''', type=str, help='''Name of the Swin timm model you\'d like to convert.''', ) parser.add_argument( '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model directory.''' ) __UpperCamelCase : List[Any] = parser.parse_args() convert_swin_checkpoint(args.swin_name, args.pytorch_dump_folder_path)
74
"""simple docstring""" def __SCREAMING_SNAKE_CASE ( A_ ): if not isinstance(A_ , A_ ): lowerCAmelCase__ : int = f'Input value of [number={number}] must be an integer' raise TypeError(A_ ) if number < 0: return False lowerCAmelCase__ : List[Any] = number * number while number > 0: if number % 10 != number_square % 10: return False number //= 10 number_square //= 10 return True if __name__ == "__main__": import doctest doctest.testmod()
74
1
def _UpperCamelCase ( snake_case__ = 50 ) -> int: __UpperCAmelCase : Optional[int] = [[0] * 3 for _ in range(length + 1 )] for row_length in range(length + 1 ): for tile_length in range(2, 5 ): for tile_start in range(row_length - tile_length + 1 ): different_colour_ways_number[row_length][tile_length - 2] += ( different_colour_ways_number[row_length - tile_start - tile_length][ tile_length - 2 ] + 1 ) return sum(different_colour_ways_number[length] ) if __name__ == "__main__": print(F'{solution() = }')
157
import warnings from typing import Dict import numpy as np from ..utils import ExplicitEnum, add_end_docstrings, is_tf_available, is_torch_available from .base import PIPELINE_INIT_ARGS, GenericTensor, Pipeline if is_tf_available(): from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING def _UpperCamelCase ( snake_case__ ) -> List[str]: return 1.0 / (1.0 + np.exp(-_outputs )) def _UpperCamelCase ( snake_case__ ) -> Optional[int]: __UpperCAmelCase : List[str] = np.max(_outputs, axis=-1, keepdims=snake_case__ ) __UpperCAmelCase : Dict = np.exp(_outputs - maxes ) return shifted_exp / shifted_exp.sum(axis=-1, keepdims=snake_case__ ) class _snake_case ( _lowercase ): lowerCamelCase__: Optional[Any] = "sigmoid" lowerCamelCase__: Dict = "softmax" lowerCamelCase__: Optional[int] = "none" @add_end_docstrings( _lowercase , R"\n return_all_scores (`bool`, *optional*, defaults to `False`):\n Whether to return all prediction scores or just the one of the predicted class.\n function_to_apply (`str`, *optional*, defaults to `\"default\"`):\n The function to apply to the model outputs in order to retrieve the scores. Accepts four different values:\n\n - `\"default\"`: if the model has a single label, will apply the sigmoid function on the output. If the model\n has several labels, will apply the softmax function on the output.\n - `\"sigmoid\"`: Applies the sigmoid function on the output.\n - `\"softmax\"`: Applies the softmax function on the output.\n - `\"none\"`: Does not apply any function on the output.\n " , ) class _snake_case ( _lowercase ): lowerCamelCase__: List[Any] = False lowerCamelCase__: Any = ClassificationFunction.NONE def __init__( self: Union[str, Any] , **__lowerCamelCase: List[Any] ) -> Optional[int]: super().__init__(**__lowerCamelCase ) self.check_model_type( TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING if self.framework == "tf" else MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING ) def _lowerCamelCase ( self: Optional[Any] , __lowerCamelCase: List[Any]=None , __lowerCamelCase: Optional[Any]=None , __lowerCamelCase: str="" , **__lowerCamelCase: str ) -> Tuple: # Using "" as default argument because we're going to use `top_k=None` in user code to declare # "No top_k" __UpperCAmelCase : Optional[int] = tokenizer_kwargs __UpperCAmelCase : str = {} if hasattr(self.model.config , "return_all_scores" ) and return_all_scores is None: __UpperCAmelCase : List[Any] = self.model.config.return_all_scores if isinstance(__lowerCamelCase , __lowerCamelCase ) or top_k is None: __UpperCAmelCase : Dict = top_k __UpperCAmelCase : str = False elif return_all_scores is not None: warnings.warn( "`return_all_scores` is now deprecated, if want a similar functionality use `top_k=None` instead of" " `return_all_scores=True` or `top_k=1` instead of `return_all_scores=False`." , __lowerCamelCase , ) if return_all_scores: __UpperCAmelCase : Any = None else: __UpperCAmelCase : Union[str, Any] = 1 if isinstance(__lowerCamelCase , __lowerCamelCase ): __UpperCAmelCase : Any = ClassificationFunction[function_to_apply.upper()] if function_to_apply is not None: __UpperCAmelCase : Any = function_to_apply return preprocess_params, {}, postprocess_params def __call__( self: Any , *__lowerCamelCase: Dict , **__lowerCamelCase: int ) -> Dict: __UpperCAmelCase : Any = super().__call__(*__lowerCamelCase , **__lowerCamelCase ) # TODO try and retrieve it in a nicer way from _sanitize_parameters. __UpperCAmelCase : Optional[Any] = "top_k" not in kwargs if isinstance(args[0] , __lowerCamelCase ) and _legacy: # This pipeline is odd, and return a list when single item is run return [result] else: return result def _lowerCamelCase ( self: Tuple , __lowerCamelCase: Dict , **__lowerCamelCase: Optional[int] ) -> Dict[str, GenericTensor]: __UpperCAmelCase : Tuple = self.framework if isinstance(__lowerCamelCase , __lowerCamelCase ): return self.tokenizer(**__lowerCamelCase , return_tensors=__lowerCamelCase , **__lowerCamelCase ) elif isinstance(__lowerCamelCase , __lowerCamelCase ) and len(__lowerCamelCase ) == 1 and isinstance(inputs[0] , __lowerCamelCase ) and len(inputs[0] ) == 2: # It used to be valid to use a list of list of list for text pairs, keeping this path for BC return self.tokenizer( text=inputs[0][0] , text_pair=inputs[0][1] , return_tensors=__lowerCamelCase , **__lowerCamelCase ) elif isinstance(__lowerCamelCase , __lowerCamelCase ): # This is likely an invalid usage of the pipeline attempting to pass text pairs. raise ValueError( "The pipeline received invalid inputs, if you are trying to send text pairs, you can try to send a" " dictionary `{\"text\": \"My text\", \"text_pair\": \"My pair\"}` in order to send a text pair." ) return self.tokenizer(__lowerCamelCase , return_tensors=__lowerCamelCase , **__lowerCamelCase ) def _lowerCamelCase ( self: Optional[int] , __lowerCamelCase: Optional[Any] ) -> List[Any]: return self.model(**__lowerCamelCase ) def _lowerCamelCase ( self: List[str] , __lowerCamelCase: Tuple , __lowerCamelCase: List[str]=None , __lowerCamelCase: Union[str, Any]=1 , __lowerCamelCase: int=True ) -> Dict: # `_legacy` is used to determine if we're running the naked pipeline and in backward # compatibility mode, or if running the pipeline with `pipeline(..., top_k=1)` we're running # the more natural result containing the list. # Default value before `set_parameters` if function_to_apply is None: if self.model.config.problem_type == "multi_label_classification" or self.model.config.num_labels == 1: __UpperCAmelCase : Union[str, Any] = ClassificationFunction.SIGMOID elif self.model.config.problem_type == "single_label_classification" or self.model.config.num_labels > 1: __UpperCAmelCase : str = ClassificationFunction.SOFTMAX elif hasattr(self.model.config , "function_to_apply" ) and function_to_apply is None: __UpperCAmelCase : Any = self.model.config.function_to_apply else: __UpperCAmelCase : Optional[Any] = ClassificationFunction.NONE __UpperCAmelCase : Tuple = model_outputs["logits"][0] __UpperCAmelCase : Optional[int] = outputs.numpy() if function_to_apply == ClassificationFunction.SIGMOID: __UpperCAmelCase : Optional[Any] = sigmoid(__lowerCamelCase ) elif function_to_apply == ClassificationFunction.SOFTMAX: __UpperCAmelCase : Any = softmax(__lowerCamelCase ) elif function_to_apply == ClassificationFunction.NONE: __UpperCAmelCase : str = outputs else: raise ValueError(f'''Unrecognized `function_to_apply` argument: {function_to_apply}''' ) if top_k == 1 and _legacy: return {"label": self.model.config.idalabel[scores.argmax().item()], "score": scores.max().item()} __UpperCAmelCase : int = [ {"label": self.model.config.idalabel[i], "score": score.item()} for i, score in enumerate(__lowerCamelCase ) ] if not _legacy: dict_scores.sort(key=lambda __lowerCamelCase : x["score"] , reverse=__lowerCamelCase ) if top_k is not None: __UpperCAmelCase : Tuple = dict_scores[:top_k] return dict_scores
157
1
from typing import Dict, List, Optional, Union import numpy as np from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict from ...image_transforms import convert_to_rgb, normalize, rescale, resize, to_channel_dimension_format from ...image_utils import ( OPENAI_CLIP_MEAN, OPENAI_CLIP_STD, ChannelDimension, ImageInput, PILImageResampling, make_list_of_images, to_numpy_array, valid_images, ) from ...utils import TensorType, is_vision_available, logging if is_vision_available(): import PIL _UpperCamelCase = logging.get_logger(__name__) class lowercase ( _UpperCamelCase ): '''simple docstring''' __SCREAMING_SNAKE_CASE = ["""pixel_values"""] def __init__(self , __a = True , __a = None , __a = PILImageResampling.BICUBIC , __a = True , __a = 1 / 255 , __a = True , __a = None , __a = None , __a = True , **__a , ) -> None: """simple docstring""" super().__init__(**__a ) UpperCAmelCase__ = size if size is not None else {'height': 384, 'width': 384} UpperCAmelCase__ = get_size_dict(__a , default_to_square=__a ) UpperCAmelCase__ = do_resize UpperCAmelCase__ = size UpperCAmelCase__ = resample UpperCAmelCase__ = do_rescale UpperCAmelCase__ = rescale_factor UpperCAmelCase__ = do_normalize UpperCAmelCase__ = image_mean if image_mean is not None else OPENAI_CLIP_MEAN UpperCAmelCase__ = image_std if image_std is not None else OPENAI_CLIP_STD UpperCAmelCase__ = do_convert_rgb def UpperCamelCase__ (self , __a , __a , __a = PILImageResampling.BICUBIC , __a = None , **__a , ) -> np.ndarray: """simple docstring""" UpperCAmelCase__ = get_size_dict(__a , default_to_square=__a ) if "height" not in size or "width" not in size: raise ValueError(F"The `size` dictionary must contain the keys `height` and `width`. Got {size.keys()}" ) UpperCAmelCase__ = (size['height'], size['width']) return resize(__a , size=__a , resample=__a , data_format=__a , **__a ) def UpperCamelCase__ (self , __a , __a , __a = None , **__a , ) -> Tuple: """simple docstring""" return rescale(__a , scale=__a , data_format=__a , **__a ) def UpperCamelCase__ (self , __a , __a , __a , __a = None , **__a , ) -> np.ndarray: """simple docstring""" return normalize(__a , mean=__a , std=__a , data_format=__a , **__a ) def UpperCamelCase__ (self , __a , __a = None , __a = None , __a = None , __a = None , __a = None , __a = None , __a = None , __a = None , __a = None , __a = None , __a = ChannelDimension.FIRST , **__a , ) -> PIL.Image.Image: """simple docstring""" UpperCAmelCase__ = do_resize if do_resize is not None else self.do_resize UpperCAmelCase__ = resample if resample is not None else self.resample UpperCAmelCase__ = do_rescale if do_rescale is not None else self.do_rescale UpperCAmelCase__ = rescale_factor if rescale_factor is not None else self.rescale_factor UpperCAmelCase__ = do_normalize if do_normalize is not None else self.do_normalize UpperCAmelCase__ = image_mean if image_mean is not None else self.image_mean UpperCAmelCase__ = image_std if image_std is not None else self.image_std UpperCAmelCase__ = do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb UpperCAmelCase__ = size if size is not None else self.size UpperCAmelCase__ = get_size_dict(__a , default_to_square=__a ) UpperCAmelCase__ = make_list_of_images(__a ) if not valid_images(__a ): raise ValueError( 'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, ' 'torch.Tensor, tf.Tensor or jax.ndarray.' ) if do_resize and size is None or resample is None: raise ValueError('Size and resample must be specified if do_resize is True.' ) if do_rescale and rescale_factor is None: raise ValueError('Rescale factor must be specified if do_rescale is True.' ) if do_normalize and (image_mean is None or image_std is None): raise ValueError('Image mean and std must be specified if do_normalize is True.' ) # PIL RGBA images are converted to RGB if do_convert_rgb: UpperCAmelCase__ = [convert_to_rgb(__a ) for image in images] # All transformations expect numpy arrays. UpperCAmelCase__ = [to_numpy_array(__a ) for image in images] if do_resize: UpperCAmelCase__ = [self.resize(image=__a , size=__a , resample=__a ) for image in images] if do_rescale: UpperCAmelCase__ = [self.rescale(image=__a , scale=__a ) for image in images] if do_normalize: UpperCAmelCase__ = [self.normalize(image=__a , mean=__a , std=__a ) for image in images] UpperCAmelCase__ = [to_channel_dimension_format(__a , __a ) for image in images] UpperCAmelCase__ = BatchFeature(data={'pixel_values': images} , tensor_type=__a ) return encoded_outputs
335
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available _UpperCamelCase = { '''configuration_squeezebert''': [ '''SQUEEZEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''SqueezeBertConfig''', '''SqueezeBertOnnxConfig''', ], '''tokenization_squeezebert''': ['''SqueezeBertTokenizer'''], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _UpperCamelCase = ['''SqueezeBertTokenizerFast'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _UpperCamelCase = [ '''SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST''', '''SqueezeBertForMaskedLM''', '''SqueezeBertForMultipleChoice''', '''SqueezeBertForQuestionAnswering''', '''SqueezeBertForSequenceClassification''', '''SqueezeBertForTokenClassification''', '''SqueezeBertModel''', '''SqueezeBertModule''', '''SqueezeBertPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_squeezebert import ( SQUEEZEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, SqueezeBertConfig, SqueezeBertOnnxConfig, ) from .tokenization_squeezebert import SqueezeBertTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_squeezebert_fast import SqueezeBertTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_squeezebert import ( SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST, SqueezeBertForMaskedLM, SqueezeBertForMultipleChoice, SqueezeBertForQuestionAnswering, SqueezeBertForSequenceClassification, SqueezeBertForTokenClassification, SqueezeBertModel, SqueezeBertModule, SqueezeBertPreTrainedModel, ) else: import sys _UpperCamelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
335
1
"""simple docstring""" # Lint as: python3 import itertools import os import re _A : List[Any] = re.compile(r"""([A-Z]+)([A-Z][a-z])""") _A : Any = re.compile(r"""([a-z\d])([A-Z])""") _A : Optional[int] = re.compile(r"""(?<!_)_(?!_)""") _A : int = re.compile(r"""(_{2,})""") _A : List[str] = r'''^\w+(\.\w+)*$''' _A : Union[str, Any] = r'''<>:/\|?*''' def __magic_name__ ( __snake_case : Any ) -> Dict: lowercase : List[Any] = _uppercase_uppercase_re.sub(r"\1_\2" , __lowercase ) lowercase : int = _lowercase_uppercase_re.sub(r"\1_\2" , __lowercase ) return name.lower() def __magic_name__ ( __snake_case : List[Any] ) -> Union[str, Any]: lowercase : int = _single_underscore_re.split(__lowercase ) lowercase : Any = [_multiple_underscores_re.split(__lowercase ) for n in name] return "".join(n.capitalize() for n in itertools.chain.from_iterable(__lowercase ) if n != "" ) def __magic_name__ ( __snake_case : Union[str, Any] ) -> Union[str, Any]: if os.path.basename(__lowercase ) != name: raise ValueError(f"""Should be a dataset name, not a path: {name}""" ) return camelcase_to_snakecase(__lowercase ) def __magic_name__ ( __snake_case : Tuple , __snake_case : List[str] ) -> Optional[Any]: if os.path.basename(__lowercase ) != name: raise ValueError(f"""Should be a dataset name, not a path: {name}""" ) if not re.match(_split_re , __lowercase ): raise ValueError(f"""Split name should match \'{_split_re}\'\' but got \'{split}\'.""" ) return f"""{filename_prefix_for_name(__lowercase )}-{split}""" def __magic_name__ ( __snake_case : Union[str, Any] , __snake_case : str , __snake_case : int , __snake_case : Tuple=None ) -> int: lowercase : int = filename_prefix_for_split(__lowercase , __lowercase ) if filetype_suffix: prefix += f""".{filetype_suffix}""" lowercase : List[str] = os.path.join(__lowercase , __lowercase ) return f"""{filepath}*""" def __magic_name__ ( __snake_case : List[Any] , __snake_case : List[str] , __snake_case : str , __snake_case : int=None , __snake_case : int=None ) -> Union[str, Any]: lowercase : List[str] = filename_prefix_for_split(__lowercase , __lowercase ) lowercase : Optional[int] = os.path.join(__lowercase , __lowercase ) if shard_lengths: lowercase : Tuple = len(__lowercase ) lowercase : List[Any] = [f"""{prefix}-{shard_id:05d}-of-{num_shards:05d}""" for shard_id in range(__lowercase )] if filetype_suffix: lowercase : Dict = [filename + f""".{filetype_suffix}""" for filename in filenames] return filenames else: lowercase : List[Any] = prefix if filetype_suffix: filename += f""".{filetype_suffix}""" return [filename]
202
from __future__ import annotations from typing import Any class SCREAMING_SNAKE_CASE__ : '''simple docstring''' def __init__( self : Tuple , lowercase : int , lowercase : int , lowercase : float = 0 ): '''simple docstring''' _snake_case , _snake_case = row, column _snake_case = [[default_value for c in range(lowercase )] for r in range(lowercase )] def __str__( self : int ): '''simple docstring''' _snake_case = f'''Matrix consist of {self.row} rows and {self.column} columns\n''' # Make string identifier _snake_case = 0 for row_vector in self.array: for obj in row_vector: _snake_case = max(lowercase , len(str(lowercase ) ) ) _snake_case = f'''%{max_element_length}s''' # Make string and return def single_line(lowercase : list[float] ) -> str: nonlocal string_format_identifier _snake_case = '[' line += ", ".join(string_format_identifier % (obj,) for obj in row_vector ) line += "]" return line s += "\n".join(single_line(lowercase ) for row_vector in self.array ) return s def __repr__( self : Dict ): '''simple docstring''' return str(self ) def A ( self : str , lowercase : tuple[int, int] ): '''simple docstring''' if not (isinstance(lowercase , (list, tuple) ) and len(lowercase ) == 2): return False elif not (0 <= loc[0] < self.row and 0 <= loc[1] < self.column): return False else: return True def __getitem__( self : Dict , lowercase : tuple[int, int] ): '''simple docstring''' assert self.validate_indicies(lowercase ) return self.array[loc[0]][loc[1]] def __setitem__( self : str , lowercase : tuple[int, int] , lowercase : float ): '''simple docstring''' assert self.validate_indicies(lowercase ) _snake_case = value def __add__( self : str , lowercase : Matrix ): '''simple docstring''' assert isinstance(lowercase , lowercase ) assert self.row == another.row and self.column == another.column # Add _snake_case = Matrix(self.row , self.column ) for r in range(self.row ): for c in range(self.column ): _snake_case = self[r, c] + another[r, c] return result def __neg__( self : Tuple ): '''simple docstring''' _snake_case = Matrix(self.row , self.column ) for r in range(self.row ): for c in range(self.column ): _snake_case = -self[r, c] return result def __sub__( self : List[str] , lowercase : Matrix ): '''simple docstring''' return self + (-another) def __mul__( self : Dict , lowercase : int | float | Matrix ): '''simple docstring''' if isinstance(lowercase , (int, float) ): # Scalar multiplication _snake_case = Matrix(self.row , self.column ) for r in range(self.row ): for c in range(self.column ): _snake_case = self[r, c] * another return result elif isinstance(lowercase , lowercase ): # Matrix multiplication assert self.column == another.row _snake_case = Matrix(self.row , another.column ) for r in range(self.row ): for c in range(another.column ): for i in range(self.column ): result[r, c] += self[r, i] * another[i, c] return result else: _snake_case = f'''Unsupported type given for another ({type(lowercase )})''' raise TypeError(lowercase ) def A ( self : Optional[Any] ): '''simple docstring''' _snake_case = Matrix(self.column , self.row ) for r in range(self.row ): for c in range(self.column ): _snake_case = self[r, c] return result def A ( self : List[Any] , lowercase : Matrix , lowercase : Matrix ): '''simple docstring''' assert isinstance(lowercase , lowercase ) and isinstance(lowercase , lowercase ) assert self.row == self.column == u.row == v.row # u, v should be column vector assert u.column == v.column == 1 # u, v should be column vector # Calculate _snake_case = v.transpose() _snake_case = (v_t * self * u)[0, 0] + 1 if numerator_factor == 0: return None # It's not invertable return self - ((self * u) * (v_t * self) * (1.0 / numerator_factor)) # Testing if __name__ == "__main__": def a_ ( ) -> None: # a^(-1) _snake_case = Matrix(3 , 3 , 0 ) for i in range(3 ): _snake_case = 1 print(f'''a^(-1) is {ainv}''' ) # u, v _snake_case = Matrix(3 , 1 , 0 ) _snake_case , _snake_case , _snake_case = 1, 2, -3 _snake_case = Matrix(3 , 1 , 0 ) _snake_case , _snake_case , _snake_case = 4, -2, 5 print(f'''u is {u}''' ) print(f'''v is {v}''' ) print(f'''uv^T is {u * v.transpose()}''' ) # Sherman Morrison print(f'''(a + uv^T)^(-1) is {ainv.sherman_morrison(__lowercase , __lowercase )}''' ) def a_ ( ) -> None: import doctest doctest.testmod() testa()
282
0
'''simple docstring''' def __magic_name__ ( __UpperCAmelCase ) -> list[list]: '''simple docstring''' snake_case_ = current_set.copy() for row_index, row in enumerate(__UpperCAmelCase ): snake_case_ = row[0] for column_index, column in enumerate(__UpperCAmelCase ): if magnitude == 0: snake_case_ = column continue snake_case_ = column / magnitude # Subtract to cancel term snake_case_ = current_set[0] snake_case_ = [first_row] snake_case_ = current_set[1::] for row in current_set: snake_case_ = [] # If first term is 0, it is already in form we want, so we preserve it if row[0] == 0: final_set.append(__UpperCAmelCase ) continue for column_index in range(len(__UpperCAmelCase ) ): temp_row.append(first_row[column_index] - row[column_index] ) final_set.append(__UpperCAmelCase ) # Create next recursion iteration set if len(final_set[0] ) != 3: snake_case_ = final_set[0] snake_case_ = [] snake_case_ = [] for row in final_set[1::]: current_first_column.append(row[0] ) next_iteration.append(row[1::] ) snake_case_ = simplify(__UpperCAmelCase ) for i in range(len(__UpperCAmelCase ) ): resultant[i].insert(0, current_first_column[i] ) resultant.insert(0, __UpperCAmelCase ) snake_case_ = resultant return final_set def __magic_name__ ( __UpperCAmelCase ) -> list: '''simple docstring''' if len(__UpperCAmelCase ) == 0: raise IndexError('''solve_simultaneous() requires n lists of length n+1''' ) snake_case_ = len(__UpperCAmelCase ) + 1 if any(len(__UpperCAmelCase ) != _length for item in equations ): raise IndexError('''solve_simultaneous() requires n lists of length n+1''' ) for row in equations: if any(not isinstance(__UpperCAmelCase, (int, float) ) for column in row ): raise ValueError('''solve_simultaneous() requires lists of integers''' ) if len(__UpperCAmelCase ) == 1: return [equations[0][-1] / equations[0][0]] snake_case_ = equations.copy() if any(0 in row for row in data_set ): snake_case_ = data_set.copy() snake_case_ = [] for row_index, row in enumerate(__UpperCAmelCase ): if 0 not in row: snake_case_ = data_set.pop(__UpperCAmelCase ) break if not full_row: raise ValueError('''solve_simultaneous() requires at least 1 full equation''' ) data_set.insert(0, __UpperCAmelCase ) snake_case_ = data_set.copy() snake_case_ = simplify(__UpperCAmelCase ) snake_case_ = simplified[::-1] snake_case_ = [] for row in simplified: snake_case_ = row[-1] if not solutions: if row[-2] == 0: solutions.append(0 ) continue solutions.append(current_solution / row[-2] ) continue snake_case_ = row.copy()[: len(__UpperCAmelCase ) - 1 :] while temp_row[0] == 0: temp_row.pop(0 ) if len(__UpperCAmelCase ) == 0: solutions.append(0 ) continue snake_case_ = temp_row[1::] snake_case_ = temp_row[::-1] for column_index, column in enumerate(__UpperCAmelCase ): current_solution -= column * solutions[column_index] solutions.append(__UpperCAmelCase ) snake_case_ = [] for item in solutions: final.append(float(round(__UpperCAmelCase, 5 ) ) ) return final[::-1] if __name__ == "__main__": import doctest doctest.testmod() a : str = [ [2, 1, 1, 1, 1, 4], [1, 2, 1, 1, 1, 5], [1, 1, 2, 1, 1, 6], [1, 1, 1, 2, 1, 7], [1, 1, 1, 1, 2, 8], ] print(solve_simultaneous(eq)) print(solve_simultaneous([[4, 2]]))
72
'''simple docstring''' from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging a : Optional[int] = logging.get_logger(__name__) a : Optional[Any] = { 'facebook/xlm-roberta-xl': 'https://huggingface.co/facebook/xlm-roberta-xl/resolve/main/config.json', 'facebook/xlm-roberta-xxl': 'https://huggingface.co/facebook/xlm-roberta-xxl/resolve/main/config.json', # See all XLM-RoBERTa-XL models at https://huggingface.co/models?filter=xlm-roberta-xl } class a ( _lowerCamelCase ): snake_case_ = "xlm-roberta-xl" def __init__( self : Optional[Any] , lowercase_ : Optional[Any]=25_0880 , lowercase_ : Tuple=2560 , lowercase_ : str=36 , lowercase_ : List[str]=32 , lowercase_ : Optional[Any]=1_0240 , lowercase_ : List[str]="gelu" , lowercase_ : Union[str, Any]=0.1 , lowercase_ : Union[str, Any]=0.1 , lowercase_ : str=514 , lowercase_ : Any=1 , lowercase_ : Optional[Any]=0.02 , lowercase_ : Dict=1e-05 , lowercase_ : List[Any]=1 , lowercase_ : str=0 , lowercase_ : Dict=2 , lowercase_ : Optional[Any]="absolute" , lowercase_ : str=True , lowercase_ : str=None , **lowercase_ : Tuple , ): super().__init__(pad_token_id=lowercase_ , bos_token_id=lowercase_ , eos_token_id=lowercase_ , **lowercase_ ) snake_case_ = vocab_size snake_case_ = hidden_size snake_case_ = num_hidden_layers snake_case_ = num_attention_heads snake_case_ = hidden_act snake_case_ = intermediate_size snake_case_ = hidden_dropout_prob snake_case_ = attention_probs_dropout_prob snake_case_ = max_position_embeddings snake_case_ = type_vocab_size snake_case_ = initializer_range snake_case_ = layer_norm_eps snake_case_ = position_embedding_type snake_case_ = use_cache snake_case_ = classifier_dropout class a ( _lowerCamelCase ): @property def A_ ( self : Optional[Any] ): if self.task == "multiple-choice": snake_case_ = {0: '''batch''', 1: '''choice''', 2: '''sequence'''} else: snake_case_ = {0: '''batch''', 1: '''sequence'''} return OrderedDict( [ ('''input_ids''', dynamic_axis), ('''attention_mask''', dynamic_axis), ] )
72
1
'''simple docstring''' import os import torch from ..logging import get_logger from .constants import FSDP_PYTORCH_VERSION, MODEL_NAME, OPTIMIZER_NAME from .versions import is_torch_version if is_torch_version(">=", FSDP_PYTORCH_VERSION): import torch.distributed.checkpoint as dist_cp from torch.distributed.checkpoint.default_planner import DefaultLoadPlanner, DefaultSavePlanner from torch.distributed.checkpoint.optimizer import load_sharded_optimizer_state_dict from torch.distributed.fsdp.fully_sharded_data_parallel import FullyShardedDataParallel as FSDP from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType a : str = get_logger(__name__) def lowercase ( __magic_name__ , __magic_name__ , __magic_name__ , __magic_name__ , __magic_name__=0 ): '''simple docstring''' os.makedirs(__magic_name__ , exist_ok=__magic_name__ ) with FSDP.state_dict_type( __magic_name__ , fsdp_plugin.state_dict_type , fsdp_plugin.state_dict_config , fsdp_plugin.optim_state_dict_config ): UpperCAmelCase : Dict = model.state_dict() if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT: UpperCAmelCase : Optional[Any] = F"{MODEL_NAME}.bin" if model_index == 0 else F"{MODEL_NAME}_{model_index}.bin" UpperCAmelCase : str = os.path.join(__magic_name__ , __magic_name__ ) if accelerator.process_index == 0: logger.info(F"Saving model to {output_model_file}" ) torch.save(__magic_name__ , __magic_name__ ) logger.info(F"Model saved to {output_model_file}" ) elif fsdp_plugin.state_dict_type == StateDictType.LOCAL_STATE_DICT: UpperCAmelCase : str = ( F"{MODEL_NAME}_rank{accelerator.process_index}.bin" if model_index == 0 else F"{MODEL_NAME}_{model_index}_rank{accelerator.process_index}.bin" ) UpperCAmelCase : Any = os.path.join(__magic_name__ , __magic_name__ ) logger.info(F"Saving model to {output_model_file}" ) torch.save(__magic_name__ , __magic_name__ ) logger.info(F"Model saved to {output_model_file}" ) elif fsdp_plugin.state_dict_type == StateDictType.SHARDED_STATE_DICT: UpperCAmelCase : Optional[Any] = os.path.join(__magic_name__ , F"{MODEL_NAME}_{model_index}" ) os.makedirs(__magic_name__ , exist_ok=__magic_name__ ) logger.info(F"Saving model to {ckpt_dir}" ) UpperCAmelCase : Dict = {"model": state_dict} dist_cp.save_state_dict( state_dict=__magic_name__ , storage_writer=dist_cp.FileSystemWriter(__magic_name__ ) , planner=DefaultSavePlanner() , ) logger.info(F"Model saved to {ckpt_dir}" ) def lowercase ( __magic_name__ , __magic_name__ , __magic_name__ , __magic_name__ , __magic_name__=0 ): '''simple docstring''' accelerator.wait_for_everyone() with FSDP.state_dict_type( __magic_name__ , fsdp_plugin.state_dict_type , fsdp_plugin.state_dict_config , fsdp_plugin.optim_state_dict_config ): if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT: if type(__magic_name__ ) != FSDP and accelerator.process_index != 0: if not fsdp_plugin.sync_module_states: raise ValueError( "Set the `sync_module_states` flag to `True` so that model states are synced across processes when " "initializing FSDP object" ) return UpperCAmelCase : List[Any] = F"{MODEL_NAME}.bin" if model_index == 0 else F"{MODEL_NAME}_{model_index}.bin" UpperCAmelCase : Dict = os.path.join(__magic_name__ , __magic_name__ ) logger.info(F"Loading model from {input_model_file}" ) UpperCAmelCase : Dict = torch.load(__magic_name__ ) logger.info(F"Model loaded from {input_model_file}" ) elif fsdp_plugin.state_dict_type == StateDictType.LOCAL_STATE_DICT: UpperCAmelCase : Any = ( F"{MODEL_NAME}_rank{accelerator.process_index}.bin" if model_index == 0 else F"{MODEL_NAME}_{model_index}_rank{accelerator.process_index}.bin" ) UpperCAmelCase : Union[str, Any] = os.path.join(__magic_name__ , __magic_name__ ) logger.info(F"Loading model from {input_model_file}" ) UpperCAmelCase : Dict = torch.load(__magic_name__ ) logger.info(F"Model loaded from {input_model_file}" ) elif fsdp_plugin.state_dict_type == StateDictType.SHARDED_STATE_DICT: UpperCAmelCase : Any = ( os.path.join(__magic_name__ , F"{MODEL_NAME}_{model_index}" ) if F"{MODEL_NAME}" not in input_dir else input_dir ) logger.info(F"Loading model from {ckpt_dir}" ) UpperCAmelCase : List[Any] = {"model": model.state_dict()} dist_cp.load_state_dict( state_dict=__magic_name__ , storage_reader=dist_cp.FileSystemReader(__magic_name__ ) , planner=DefaultLoadPlanner() , ) UpperCAmelCase : Any = state_dict["model"] logger.info(F"Model loaded from {ckpt_dir}" ) model.load_state_dict(__magic_name__ ) def lowercase ( __magic_name__ , __magic_name__ , __magic_name__ , __magic_name__ , __magic_name__ , __magic_name__=0 ): '''simple docstring''' os.makedirs(__magic_name__ , exist_ok=__magic_name__ ) with FSDP.state_dict_type( __magic_name__ , fsdp_plugin.state_dict_type , fsdp_plugin.state_dict_config , fsdp_plugin.optim_state_dict_config ): UpperCAmelCase : int = FSDP.optim_state_dict(__magic_name__ , __magic_name__ ) if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT: if accelerator.process_index == 0: UpperCAmelCase : Optional[int] = ( F"{OPTIMIZER_NAME}.bin" if optimizer_index == 0 else F"{OPTIMIZER_NAME}_{optimizer_index}.bin" ) UpperCAmelCase : List[str] = os.path.join(__magic_name__ , __magic_name__ ) logger.info(F"Saving Optimizer state to {output_optimizer_file}" ) torch.save(__magic_name__ , __magic_name__ ) logger.info(F"Optimizer state saved in {output_optimizer_file}" ) else: UpperCAmelCase : Any = os.path.join(__magic_name__ , F"{OPTIMIZER_NAME}_{optimizer_index}" ) os.makedirs(__magic_name__ , exist_ok=__magic_name__ ) logger.info(F"Saving Optimizer state to {ckpt_dir}" ) dist_cp.save_state_dict( state_dict={"optimizer": optim_state} , storage_writer=dist_cp.FileSystemWriter(__magic_name__ ) , planner=DefaultSavePlanner() , ) logger.info(F"Optimizer state saved in {ckpt_dir}" ) def lowercase ( __magic_name__ , __magic_name__ , __magic_name__ , __magic_name__ , __magic_name__ , __magic_name__=0 ): '''simple docstring''' accelerator.wait_for_everyone() with FSDP.state_dict_type( __magic_name__ , fsdp_plugin.state_dict_type , fsdp_plugin.state_dict_config , fsdp_plugin.optim_state_dict_config ): if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT: UpperCAmelCase : Union[str, Any] = None # below check should work but currently it isn't working (mostly opytorch issue), # in the meantime disabling it at the cost of excess memory usage # if accelerator.process_index == 0 or not fsdp_plugin.optim_state_dict_config.rank0_only: UpperCAmelCase : Any = ( F"{OPTIMIZER_NAME}.bin" if optimizer_index == 0 else F"{OPTIMIZER_NAME}_{optimizer_index}.bin" ) UpperCAmelCase : int = os.path.join(__magic_name__ , __magic_name__ ) logger.info(F"Loading Optimizer state from {input_optimizer_file}" ) UpperCAmelCase : Optional[Any] = torch.load(__magic_name__ ) logger.info(F"Optimizer state loaded from {input_optimizer_file}" ) else: UpperCAmelCase : Tuple = ( os.path.join(__magic_name__ , F"{OPTIMIZER_NAME}_{optimizer_index}" ) if F"{OPTIMIZER_NAME}" not in input_dir else input_dir ) logger.info(F"Loading Optimizer from {ckpt_dir}" ) UpperCAmelCase : int = load_sharded_optimizer_state_dict( model_state_dict=model.state_dict() , optimizer_key="optimizer" , storage_reader=dist_cp.FileSystemReader(__magic_name__ ) , ) UpperCAmelCase : int = optim_state["optimizer"] logger.info(F"Optimizer loaded from {ckpt_dir}" ) UpperCAmelCase : str = FSDP.optim_state_dict_to_load(__magic_name__ , __magic_name__ , __magic_name__ ) optimizer.load_state_dict(__magic_name__ )
311
'''simple docstring''' import os import tempfile import unittest from transformers import is_torch_available from transformers.testing_utils import require_torch if is_torch_available(): import torch from torch import nn from transformers import ( Adafactor, AdamW, get_constant_schedule, get_constant_schedule_with_warmup, get_cosine_schedule_with_warmup, get_cosine_with_hard_restarts_schedule_with_warmup, get_inverse_sqrt_schedule, get_linear_schedule_with_warmup, get_polynomial_decay_schedule_with_warmup, ) def lowercase ( __magic_name__ , __magic_name__=10 ): '''simple docstring''' UpperCAmelCase : Tuple = [] for _ in range(__magic_name__ ): lrs.append(scheduler.get_lr()[0] ) scheduler.step() return lrs def lowercase ( __magic_name__ , __magic_name__=10 ): '''simple docstring''' UpperCAmelCase : List[str] = [] for step in range(__magic_name__ ): lrs.append(scheduler.get_lr()[0] ) scheduler.step() if step == num_steps // 2: with tempfile.TemporaryDirectory() as tmpdirname: UpperCAmelCase : Any = os.path.join(__magic_name__ , "schedule.bin" ) torch.save(scheduler.state_dict() , __magic_name__ ) UpperCAmelCase : Any = torch.load(__magic_name__ ) scheduler.load_state_dict(__magic_name__ ) return lrs @require_torch class UpperCamelCase__ ( unittest.TestCase ): """simple docstring""" def A_ ( self , snake_case , snake_case , snake_case ): '''simple docstring''' self.assertEqual(len(snake_case ) , len(snake_case ) ) for a, b in zip(snake_case , snake_case ): self.assertAlmostEqual(snake_case , snake_case , delta=snake_case ) def A_ ( self ): '''simple docstring''' UpperCAmelCase : Dict = torch.tensor([0.1, -0.2, -0.1] , requires_grad=snake_case ) UpperCAmelCase : Any = torch.tensor([0.4, 0.2, -0.5] ) UpperCAmelCase : Any = nn.MSELoss() # No warmup, constant schedule, no gradient clipping UpperCAmelCase : List[str] = AdamW(params=[w] , lr=2e-1 , weight_decay=0.0 ) for _ in range(1_0_0 ): UpperCAmelCase : List[Any] = criterion(snake_case , snake_case ) loss.backward() optimizer.step() w.grad.detach_() # No zero_grad() function on simple tensors. we do it ourselves. w.grad.zero_() self.assertListAlmostEqual(w.tolist() , [0.4, 0.2, -0.5] , tol=1e-2 ) def A_ ( self ): '''simple docstring''' UpperCAmelCase : Tuple = torch.tensor([0.1, -0.2, -0.1] , requires_grad=snake_case ) UpperCAmelCase : int = torch.tensor([0.4, 0.2, -0.5] ) UpperCAmelCase : str = nn.MSELoss() # No warmup, constant schedule, no gradient clipping UpperCAmelCase : str = Adafactor( params=[w] , lr=1e-2 , eps=(1e-30, 1e-3) , clip_threshold=1.0 , decay_rate=-0.8 , betaa=snake_case , weight_decay=0.0 , relative_step=snake_case , scale_parameter=snake_case , warmup_init=snake_case , ) for _ in range(1_0_0_0 ): UpperCAmelCase : str = criterion(snake_case , snake_case ) loss.backward() optimizer.step() w.grad.detach_() # No zero_grad() function on simple tensors. we do it ourselves. w.grad.zero_() self.assertListAlmostEqual(w.tolist() , [0.4, 0.2, -0.5] , tol=1e-2 ) @require_torch class UpperCamelCase__ ( unittest.TestCase ): """simple docstring""" SCREAMING_SNAKE_CASE__ : Optional[int] = nn.Linear(50 , 50 ) if is_torch_available() else None SCREAMING_SNAKE_CASE__ : List[Any] = AdamW(m.parameters() , lr=1_0.0 ) if is_torch_available() else None SCREAMING_SNAKE_CASE__ : Optional[int] = 10 def A_ ( self , snake_case , snake_case , snake_case , snake_case=None ): '''simple docstring''' self.assertEqual(len(snake_case ) , len(snake_case ) ) for a, b in zip(snake_case , snake_case ): self.assertAlmostEqual(snake_case , snake_case , delta=snake_case , msg=snake_case ) def A_ ( self ): '''simple docstring''' UpperCAmelCase : int = {"num_warmup_steps": 2, "num_training_steps": 1_0} # schedulers doct format # function: (sched_args_dict, expected_learning_rates) UpperCAmelCase : int = { get_constant_schedule: ({}, [10.0] * self.num_steps), get_constant_schedule_with_warmup: ( {"num_warmup_steps": 4}, [0.0, 2.5, 5.0, 7.5, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0], ), get_linear_schedule_with_warmup: ( {**common_kwargs}, [0.0, 5.0, 10.0, 8.75, 7.5, 6.25, 5.0, 3.75, 2.5, 1.25], ), get_cosine_schedule_with_warmup: ( {**common_kwargs}, [0.0, 5.0, 10.0, 9.61, 8.53, 6.91, 5.0, 3.08, 1.46, 0.38], ), get_cosine_with_hard_restarts_schedule_with_warmup: ( {**common_kwargs, "num_cycles": 2}, [0.0, 5.0, 10.0, 8.53, 5.0, 1.46, 10.0, 8.53, 5.0, 1.46], ), get_polynomial_decay_schedule_with_warmup: ( {**common_kwargs, "power": 2.0, "lr_end": 1e-7}, [0.0, 5.0, 10.0, 7.656, 5.625, 3.906, 2.5, 1.406, 0.625, 0.156], ), get_inverse_sqrt_schedule: ( {"num_warmup_steps": 2}, [0.0, 5.0, 10.0, 8.165, 7.071, 6.325, 5.774, 5.345, 5.0, 4.714], ), } for scheduler_func, data in scheds.items(): UpperCAmelCase , UpperCAmelCase : Any = data UpperCAmelCase : Tuple = scheduler_func(self.optimizer , **snake_case ) self.assertEqual(len([scheduler.get_lr()[0]] ) , 1 ) UpperCAmelCase : List[str] = unwrap_schedule(snake_case , self.num_steps ) self.assertListAlmostEqual( snake_case , snake_case , tol=1e-2 , msg=f"failed for {scheduler_func} in normal scheduler" , ) UpperCAmelCase : Optional[Any] = scheduler_func(self.optimizer , **snake_case ) if scheduler_func.__name__ != "get_constant_schedule": LambdaScheduleWrapper.wrap_scheduler(snake_case ) # wrap to test picklability of the schedule UpperCAmelCase : Tuple = unwrap_and_save_reload_schedule(snake_case , self.num_steps ) self.assertListEqual(snake_case , snake_case , msg=f"failed for {scheduler_func} in save and reload" ) class UpperCamelCase__ : """simple docstring""" def __init__( self , snake_case ): '''simple docstring''' UpperCAmelCase : List[str] = fn def __call__( self , *snake_case , **snake_case ): '''simple docstring''' return self.fn(*snake_case , **snake_case ) @classmethod def A_ ( self , snake_case ): '''simple docstring''' UpperCAmelCase : Optional[int] = list(map(self , scheduler.lr_lambdas ) )
311
1
import inspect import jax import jax.lax as lax import jax.numpy as jnp from ..utils import add_start_docstrings from ..utils.logging import get_logger lowerCamelCase__ = get_logger(__name__) lowerCamelCase__ = R''' Args: input_ids (`jnp.ndarray` of shape `(batch_size, sequence_length)`): Indices of input sequence tokens in the vocabulary. Indices can be obtained using [`PreTrainedTokenizer`]. See [`PreTrainedTokenizer.encode`] and [`PreTrainedTokenizer.__call__`] for details. [What are input IDs?](../glossary#input-ids) scores (`jnp.ndarray` of shape `(batch_size, config.vocab_size)`): Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search kwargs (`Dict[str, Any]`, *optional*): Additional logits processor specific kwargs. Return: `jnp.ndarray` of shape `(batch_size, config.vocab_size)`: The processed prediction scores. ''' class _UpperCAmelCase : '''simple docstring''' @add_start_docstrings(lowercase_) def __call__( self : Union[str, Any] , lowercase_ : jnp.ndarray , lowercase_ : jnp.ndarray) -> jnp.ndarray: """simple docstring""" raise NotImplementedError( f'{self.__class__} is an abstract class. Only classes inheriting this class can be called.') class _UpperCAmelCase : '''simple docstring''' @add_start_docstrings(lowercase_) def __call__( self : Optional[int] , lowercase_ : jnp.ndarray , lowercase_ : jnp.ndarray) -> jnp.ndarray: """simple docstring""" raise NotImplementedError( f'{self.__class__} is an abstract class. Only classes inheriting this class can be called.') class _UpperCAmelCase ( lowerCAmelCase ): '''simple docstring''' @add_start_docstrings(lowercase_) def __call__( self : Union[str, Any] , lowercase_ : jnp.ndarray , lowercase_ : jnp.ndarray , lowercase_ : int , **lowercase_ : List[Any]) -> jnp.ndarray: """simple docstring""" for processor in self: _UpperCamelCase = inspect.signature(processor.__call__).parameters if len(lowercase_) > 3: if not all(arg in kwargs for arg in list(function_args.keys())[2:]): raise ValueError( f'Make sure that all the required parameters: {list(function_args.keys())} for ' f'{processor.__class__} are passed to the logits processor.') _UpperCamelCase = processor(lowercase_ , lowercase_ , lowercase_ , **lowercase_) else: _UpperCamelCase = processor(lowercase_ , lowercase_ , lowercase_) return scores class _UpperCAmelCase ( lowerCAmelCase ): '''simple docstring''' def __init__( self : Optional[int] , lowercase_ : float) -> Any: """simple docstring""" if not isinstance(lowercase_ , lowercase_) or not (temperature > 0): raise ValueError(f'`temperature` has to be a strictly positive float, but is {temperature}') _UpperCamelCase = temperature def __call__( self : Tuple , lowercase_ : jnp.ndarray , lowercase_ : jnp.ndarray , lowercase_ : int) -> jnp.ndarray: """simple docstring""" _UpperCamelCase = scores / self.temperature return scores class _UpperCAmelCase ( lowerCAmelCase ): '''simple docstring''' def __init__( self : Optional[Any] , lowercase_ : float , lowercase_ : float = -float("Inf") , lowercase_ : int = 1) -> int: """simple docstring""" if not isinstance(lowercase_ , lowercase_) or (top_p < 0 or top_p > 1.0): raise ValueError(f'`top_p` has to be a float > 0 and < 1, but is {top_p}') if not isinstance(lowercase_ , lowercase_) or (min_tokens_to_keep < 1): raise ValueError(f'`min_tokens_to_keep` has to be a positive integer, but is {min_tokens_to_keep}') _UpperCamelCase = top_p _UpperCamelCase = filter_value _UpperCamelCase = min_tokens_to_keep def __call__( self : Optional[Any] , lowercase_ : jnp.ndarray , lowercase_ : jnp.ndarray , lowercase_ : int) -> jnp.ndarray: """simple docstring""" _UpperCamelCase , _UpperCamelCase = lax.top_k(lowercase_ , scores.shape[-1]) _UpperCamelCase = jnp.full_like(lowercase_ , self.filter_value) _UpperCamelCase = jax.nn.softmax(lowercase_ , axis=-1).cumsum(axis=-1) _UpperCamelCase = cumulative_probs < self.top_p # include the token that is higher than top_p as well _UpperCamelCase = jnp.roll(lowercase_ , 1) score_mask |= score_mask.at[:, 0].set(lowercase_) # min tokens to keep _UpperCamelCase = score_mask.at[:, : self.min_tokens_to_keep].set(lowercase_) _UpperCamelCase = jnp.where(lowercase_ , lowercase_ , lowercase_) _UpperCamelCase = jax.lax.sort_key_val(lowercase_ , lowercase_)[-1] return next_scores class _UpperCAmelCase ( lowerCAmelCase ): '''simple docstring''' def __init__( self : Any , lowercase_ : int , lowercase_ : float = -float("Inf") , lowercase_ : int = 1) -> List[str]: """simple docstring""" if not isinstance(lowercase_ , lowercase_) or top_k <= 0: raise ValueError(f'`top_k` has to be a strictly positive integer, but is {top_k}') _UpperCamelCase = max(lowercase_ , lowercase_) _UpperCamelCase = filter_value def __call__( self : str , lowercase_ : jnp.ndarray , lowercase_ : jnp.ndarray , lowercase_ : int) -> jnp.ndarray: """simple docstring""" _UpperCamelCase , _UpperCamelCase = scores.shape _UpperCamelCase = jnp.full(batch_size * vocab_size , self.filter_value) _UpperCamelCase = min(self.top_k , scores.shape[-1]) # Safety check _UpperCamelCase , _UpperCamelCase = lax.top_k(lowercase_ , lowercase_) _UpperCamelCase = jnp.broadcast_to((jnp.arange(lowercase_) * vocab_size)[:, None] , (batch_size, topk)).flatten() _UpperCamelCase = topk_scores.flatten() _UpperCamelCase = topk_indices.flatten() + shift _UpperCamelCase = next_scores_flat.at[topk_indices_flat].set(lowercase_) _UpperCamelCase = next_scores_flat.reshape(lowercase_ , lowercase_) return next_scores class _UpperCAmelCase ( lowerCAmelCase ): '''simple docstring''' def __init__( self : Optional[Any] , lowercase_ : int) -> Dict: """simple docstring""" _UpperCamelCase = bos_token_id def __call__( self : int , lowercase_ : jnp.ndarray , lowercase_ : jnp.ndarray , lowercase_ : int) -> jnp.ndarray: """simple docstring""" _UpperCamelCase = jnp.full(scores.shape , -float("inf")) _UpperCamelCase = 1 - jnp.bool_(cur_len - 1) _UpperCamelCase = jnp.where(lowercase_ , new_scores.at[:, self.bos_token_id].set(0) , lowercase_) return scores class _UpperCAmelCase ( lowerCAmelCase ): '''simple docstring''' def __init__( self : Optional[Any] , lowercase_ : int , lowercase_ : int) -> Optional[Any]: """simple docstring""" _UpperCamelCase = max_length _UpperCamelCase = eos_token_id def __call__( self : Tuple , lowercase_ : jnp.ndarray , lowercase_ : jnp.ndarray , lowercase_ : int) -> jnp.ndarray: """simple docstring""" _UpperCamelCase = jnp.full(scores.shape , -float("inf")) _UpperCamelCase = 1 - jnp.bool_(cur_len - self.max_length + 1) _UpperCamelCase = jnp.where(lowercase_ , new_scores.at[:, self.eos_token_id].set(0) , lowercase_) return scores class _UpperCAmelCase ( lowerCAmelCase ): '''simple docstring''' def __init__( self : Union[str, Any] , lowercase_ : int , lowercase_ : int) -> List[Any]: """simple docstring""" if not isinstance(lowercase_ , lowercase_) or min_length < 0: raise ValueError(f'`min_length` has to be a positive integer, but is {min_length}') if not isinstance(lowercase_ , lowercase_) or eos_token_id < 0: raise ValueError(f'`eos_token_id` has to be a positive integer, but is {eos_token_id}') _UpperCamelCase = min_length _UpperCamelCase = eos_token_id def __call__( self : str , lowercase_ : jnp.ndarray , lowercase_ : jnp.ndarray , lowercase_ : int) -> jnp.ndarray: """simple docstring""" _UpperCamelCase = 1 - jnp.clip(cur_len - self.min_length , 0 , 1) _UpperCamelCase = jnp.where(lowercase_ , scores.at[:, self.eos_token_id].set(-float("inf")) , lowercase_) return scores class _UpperCAmelCase ( lowerCAmelCase ): '''simple docstring''' def __init__( self : List[str] , lowercase_ : Optional[int] , lowercase_ : Optional[Any]) -> Union[str, Any]: """simple docstring""" _UpperCamelCase = list(lowercase_) _UpperCamelCase = begin_index def __call__( self : Any , lowercase_ : Optional[Any] , lowercase_ : Optional[Any] , lowercase_ : int) -> List[str]: """simple docstring""" _UpperCamelCase = 1 - jnp.bool_(cur_len - self.begin_index) _UpperCamelCase = jnp.where(lowercase_ , scores.at[:, self.begin_suppress_tokens].set(-float("inf")) , lowercase_) return scores class _UpperCAmelCase ( lowerCAmelCase ): '''simple docstring''' def __init__( self : Optional[Any] , lowercase_ : list) -> Any: """simple docstring""" _UpperCamelCase = list(lowercase_) def __call__( self : Union[str, Any] , lowercase_ : jnp.ndarray , lowercase_ : jnp.ndarray , lowercase_ : int) -> jnp.ndarray: """simple docstring""" _UpperCamelCase = scores.at[..., self.suppress_tokens].set(-float("inf")) return scores class _UpperCAmelCase ( lowerCAmelCase ): '''simple docstring''' def __init__( self : Any , lowercase_ : Union[str, Any]) -> int: """simple docstring""" _UpperCamelCase = dict(lowercase_) # Converts the dictionary of format {index: token} containing the tokens to be forced to an array, where the # index of the array corresponds to the index of the token to be forced, for XLA compatibility. # Indexes without forced tokens will have a negative value. _UpperCamelCase = jnp.ones((max(force_token_map.keys()) + 1) , dtype=jnp.intaa) * -1 for index, token in force_token_map.items(): if token is not None: _UpperCamelCase = force_token_array.at[index].set(lowercase_) _UpperCamelCase = jnp.intaa(lowercase_) def __call__( self : Dict , lowercase_ : jnp.ndarray , lowercase_ : jnp.ndarray , lowercase_ : int) -> jnp.ndarray: """simple docstring""" def _force_token(lowercase_ : int): _UpperCamelCase = scores.shape[0] _UpperCamelCase = self.force_token_array[generation_idx] _UpperCamelCase = jnp.ones_like(lowercase_ , dtype=scores.dtype) * -float("inf") _UpperCamelCase = jnp.zeros((batch_size, 1) , dtype=scores.dtype) _UpperCamelCase = lax.dynamic_update_slice(lowercase_ , lowercase_ , (0, current_token)) return new_scores _UpperCamelCase = lax.cond( cur_len >= self.force_token_array.shape[0] , lambda: scores , lambda: lax.cond( self.force_token_array[cur_len] >= 0 , lambda: _force_token(lowercase_) , lambda: scores , ) , ) return scores class _UpperCAmelCase ( lowerCAmelCase ): '''simple docstring''' def __init__( self : Dict , lowercase_ : List[Any] , lowercase_ : List[Any] , lowercase_ : List[str]) -> Optional[Any]: """simple docstring""" _UpperCamelCase = generate_config.eos_token_id _UpperCamelCase = generate_config.no_timestamps_token_id _UpperCamelCase = generate_config.no_timestamps_token_id + 1 _UpperCamelCase = decoder_input_length + 1 if generate_config.is_multilingual: # room for language token and task token self.begin_index += 2 if hasattr(lowercase_ , "max_initial_timestamp_index"): _UpperCamelCase = generate_config.max_initial_timestamp_index else: _UpperCamelCase = model_config.vocab_size if self.max_initial_timestamp_index is None: _UpperCamelCase = model_config.vocab_size def __call__( self : Tuple , lowercase_ : Tuple , lowercase_ : Tuple , lowercase_ : Optional[Any]) -> Dict: """simple docstring""" _UpperCamelCase = scores.at[:, self.no_timestamps_token_id].set(-float("inf")) def handle_pairs(lowercase_ : Optional[int] , lowercase_ : Union[str, Any]): _UpperCamelCase = jnp.where((cur_len - self.begin_index) >= 1 , lowercase_ , lowercase_) _UpperCamelCase = jnp.where( input_ids_k[cur_len - 1] >= self.timestamp_begin , True and last_was_timestamp , lowercase_ , ) _UpperCamelCase = jnp.where((cur_len - self.begin_index) < 2 , lowercase_ , lowercase_) _UpperCamelCase = jnp.where( input_ids_k[cur_len - 2] >= self.timestamp_begin , lowercase_ , lowercase_ , ) return jnp.where( lowercase_ , jnp.where( penultimate_was_timestamp > 0 , scores_k.at[self.timestamp_begin :].set(-float("inf")) , scores_k.at[: self.eos_token_id].set(-float("inf")) , ) , lowercase_ , ) _UpperCamelCase = jax.vmap(lowercase_)(lowercase_ , lowercase_) _UpperCamelCase = jnp.where(cur_len == self.begin_index , lowercase_ , lowercase_) _UpperCamelCase = jnp.where( self.max_initial_timestamp_index is not None , True and apply_max_initial_timestamp , lowercase_ , ) _UpperCamelCase = self.timestamp_begin + self.max_initial_timestamp_index _UpperCamelCase = jnp.where( lowercase_ , scores.at[:, last_allowed + 1 :].set(-float("inf")) , lowercase_ , ) # if sum of probability over timestamps is above any other token, sample timestamp _UpperCamelCase = jax.nn.log_softmax(lowercase_ , axis=-1) def handle_cumulative_probs(lowercase_ : List[Any] , lowercase_ : List[str]): _UpperCamelCase = jax.nn.logsumexp(logprobs_k[self.timestamp_begin :] , axis=-1) _UpperCamelCase = jnp.max(logprobs_k[: self.timestamp_begin]) return jnp.where( timestamp_logprob > max_text_token_logprob , scores_k.at[: self.timestamp_begin].set(-float("inf")) , lowercase_ , ) _UpperCamelCase = jax.vmap(lowercase_)(lowercase_ , lowercase_) return scores
63
import os def lowerCAmelCase__ ( ) ->Any: '''simple docstring''' with open(os.path.dirname(a__ ) + "/grid.txt" ) as f: _UpperCamelCase = [] # noqa: E741 for _ in range(20 ): l.append([int(a__ ) for x in f.readline().split()] ) _UpperCamelCase = 0 # right for i in range(20 ): for j in range(17 ): _UpperCamelCase = l[i][j] * l[i][j + 1] * l[i][j + 2] * l[i][j + 3] if temp > maximum: _UpperCamelCase = temp # down for i in range(17 ): for j in range(20 ): _UpperCamelCase = l[i][j] * l[i + 1][j] * l[i + 2][j] * l[i + 3][j] if temp > maximum: _UpperCamelCase = temp # diagonal 1 for i in range(17 ): for j in range(17 ): _UpperCamelCase = l[i][j] * l[i + 1][j + 1] * l[i + 2][j + 2] * l[i + 3][j + 3] if temp > maximum: _UpperCamelCase = temp # diagonal 2 for i in range(17 ): for j in range(3 , 20 ): _UpperCamelCase = l[i][j] * l[i + 1][j - 1] * l[i + 2][j - 2] * l[i + 3][j - 3] if temp > maximum: _UpperCamelCase = temp return maximum if __name__ == "__main__": print(solution())
63
1
'''simple docstring''' from __future__ import annotations def a__ ( lowerCAmelCase__ ) -> list[int]: UpperCAmelCase__ : List[str] = [True] * limit UpperCAmelCase__ : Optional[Any] = False UpperCAmelCase__ : List[Any] = False UpperCAmelCase__ : Optional[int] = True for i in range(3 , int(limit**0.5 + 1 ) , 2 ): UpperCAmelCase__ : Any = i * 2 while index < limit: UpperCAmelCase__ : Union[str, Any] = False UpperCAmelCase__ : Dict = index + i UpperCAmelCase__ : Optional[int] = [2] for i in range(3 , lowercase__ , 2 ): if is_prime[i]: primes.append(lowercase__ ) return primes def a__ ( lowerCAmelCase__ = 1_00_00_00 ) -> int: UpperCAmelCase__ : Any = prime_sieve(lowercase__ ) UpperCAmelCase__ : int = 0 UpperCAmelCase__ : str = 0 for i in range(len(lowercase__ ) ): for j in range(i + length , len(lowercase__ ) ): UpperCAmelCase__ : Dict = sum(primes[i:j] ) if sol >= ceiling: break if sol in primes: UpperCAmelCase__ : Tuple = j - i UpperCAmelCase__ : str = sol return largest if __name__ == "__main__": print(F"""{solution() = }""")
181
import os import tempfile import unittest from transformers import DistilBertConfig, is_torch_available from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST, DistilBertForMaskedLM, DistilBertForMultipleChoice, DistilBertForQuestionAnswering, DistilBertForSequenceClassification, DistilBertForTokenClassification, DistilBertModel, ) class A ( A_ ): def __init__(self , lowerCAmelCase , lowerCAmelCase=1_3 , lowerCAmelCase=7 , lowerCAmelCase=True , lowerCAmelCase=True , lowerCAmelCase=False , lowerCAmelCase=True , lowerCAmelCase=9_9 , lowerCAmelCase=3_2 , lowerCAmelCase=5 , lowerCAmelCase=4 , lowerCAmelCase=3_7 , lowerCAmelCase="gelu" , lowerCAmelCase=0.1 , lowerCAmelCase=0.1 , lowerCAmelCase=5_1_2 , lowerCAmelCase=1_6 , lowerCAmelCase=2 , lowerCAmelCase=0.02 , lowerCAmelCase=3 , lowerCAmelCase=4 , lowerCAmelCase=None , ): __lowercase= parent __lowercase= batch_size __lowercase= seq_length __lowercase= is_training __lowercase= use_input_mask __lowercase= use_token_type_ids __lowercase= use_labels __lowercase= vocab_size __lowercase= hidden_size __lowercase= num_hidden_layers __lowercase= num_attention_heads __lowercase= intermediate_size __lowercase= hidden_act __lowercase= hidden_dropout_prob __lowercase= attention_probs_dropout_prob __lowercase= max_position_embeddings __lowercase= type_vocab_size __lowercase= type_sequence_label_size __lowercase= initializer_range __lowercase= num_labels __lowercase= num_choices __lowercase= scope def _A (self ): __lowercase= ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) __lowercase= None if self.use_input_mask: __lowercase= random_attention_mask([self.batch_size, self.seq_length] ) __lowercase= None __lowercase= None __lowercase= None if self.use_labels: __lowercase= ids_tensor([self.batch_size] , self.type_sequence_label_size ) __lowercase= ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) __lowercase= ids_tensor([self.batch_size] , self.num_choices ) __lowercase= self.get_config() return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels def _A (self ): return 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 , ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase ): __lowercase= DistilBertModel(config=lowerCAmelCase ) model.to(lowerCAmelCase ) model.eval() __lowercase= model(lowerCAmelCase , lowerCAmelCase ) __lowercase= model(lowerCAmelCase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase ): __lowercase= DistilBertForMaskedLM(config=lowerCAmelCase ) model.to(lowerCAmelCase ) model.eval() __lowercase= model(lowerCAmelCase , attention_mask=lowerCAmelCase , labels=lowerCAmelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase ): __lowercase= DistilBertForQuestionAnswering(config=lowerCAmelCase ) model.to(lowerCAmelCase ) model.eval() __lowercase= model( lowerCAmelCase , attention_mask=lowerCAmelCase , start_positions=lowerCAmelCase , end_positions=lowerCAmelCase ) self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase ): __lowercase= self.num_labels __lowercase= DistilBertForSequenceClassification(lowerCAmelCase ) model.to(lowerCAmelCase ) model.eval() __lowercase= model(lowerCAmelCase , attention_mask=lowerCAmelCase , labels=lowerCAmelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase ): __lowercase= self.num_labels __lowercase= DistilBertForTokenClassification(config=lowerCAmelCase ) model.to(lowerCAmelCase ) model.eval() __lowercase= model(lowerCAmelCase , attention_mask=lowerCAmelCase , labels=lowerCAmelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase ): __lowercase= self.num_choices __lowercase= DistilBertForMultipleChoice(config=lowerCAmelCase ) model.to(lowerCAmelCase ) model.eval() __lowercase= input_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() __lowercase= input_mask.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() __lowercase= model( lowerCAmelCase , attention_mask=lowerCAmelCase , labels=lowerCAmelCase , ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) ) def _A (self ): __lowercase= self.prepare_config_and_inputs() ((__lowercase), (__lowercase), (__lowercase), (__lowercase), (__lowercase), (__lowercase))= config_and_inputs __lowercase= {'input_ids': input_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class A ( A_ , A_ , unittest.TestCase ): UpperCamelCase_ : Any =( ( DistilBertModel, DistilBertForMaskedLM, DistilBertForMultipleChoice, DistilBertForQuestionAnswering, DistilBertForSequenceClassification, DistilBertForTokenClassification, ) if is_torch_available() else None ) UpperCamelCase_ : Optional[int] =( { '''feature-extraction''': DistilBertModel, '''fill-mask''': DistilBertForMaskedLM, '''question-answering''': DistilBertForQuestionAnswering, '''text-classification''': DistilBertForSequenceClassification, '''token-classification''': DistilBertForTokenClassification, '''zero-shot''': DistilBertForSequenceClassification, } if is_torch_available() else {} ) UpperCamelCase_ : str =True UpperCamelCase_ : str =True UpperCamelCase_ : Union[str, Any] =True UpperCamelCase_ : Optional[int] =True def _A (self ): __lowercase= DistilBertModelTester(self ) __lowercase= ConfigTester(self , config_class=lowerCAmelCase , dim=3_7 ) def _A (self ): self.config_tester.run_common_tests() def _A (self ): __lowercase= self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_distilbert_model(*lowerCAmelCase ) def _A (self ): __lowercase= self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_distilbert_for_masked_lm(*lowerCAmelCase ) def _A (self ): __lowercase= self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_distilbert_for_question_answering(*lowerCAmelCase ) def _A (self ): __lowercase= self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_distilbert_for_sequence_classification(*lowerCAmelCase ) def _A (self ): __lowercase= self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_distilbert_for_token_classification(*lowerCAmelCase ) def _A (self ): __lowercase= self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_distilbert_for_multiple_choice(*lowerCAmelCase ) @slow def _A (self ): for model_name in DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: __lowercase= DistilBertModel.from_pretrained(lowerCAmelCase ) self.assertIsNotNone(lowerCAmelCase ) @slow @require_torch_gpu def _A (self ): __lowercase, __lowercase= self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: # BertForMultipleChoice behaves incorrectly in JIT environments. if model_class == DistilBertForMultipleChoice: return __lowercase= True __lowercase= model_class(config=lowerCAmelCase ) __lowercase= self._prepare_for_class(lowerCAmelCase , lowerCAmelCase ) __lowercase= torch.jit.trace( lowerCAmelCase , (inputs_dict['input_ids'].to('cpu' ), inputs_dict['attention_mask'].to('cpu' )) ) with tempfile.TemporaryDirectory() as tmp: torch.jit.save(lowerCAmelCase , os.path.join(lowerCAmelCase , 'traced_model.pt' ) ) __lowercase= torch.jit.load(os.path.join(lowerCAmelCase , 'traced_model.pt' ) , map_location=lowerCAmelCase ) loaded(inputs_dict['input_ids'].to(lowerCAmelCase ) , inputs_dict['attention_mask'].to(lowerCAmelCase ) ) @require_torch class A ( unittest.TestCase ): @slow def _A (self ): __lowercase= DistilBertModel.from_pretrained('distilbert-base-uncased' ) __lowercase= torch.tensor([[0, 3_4_5, 2_3_2, 3_2_8, 7_4_0, 1_4_0, 1_6_9_5, 6_9, 6_0_7_8, 1_5_8_8, 2]] ) __lowercase= torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] ) with torch.no_grad(): __lowercase= model(lowerCAmelCase , attention_mask=lowerCAmelCase )[0] __lowercase= torch.Size((1, 1_1, 7_6_8) ) self.assertEqual(output.shape , lowerCAmelCase ) __lowercase= torch.tensor( [[[-0.16_39, 0.32_99, 0.16_48], [-0.17_46, 0.32_89, 0.17_10], [-0.18_84, 0.33_57, 0.18_10]]] ) self.assertTrue(torch.allclose(output[:, 1:4, 1:4] , lowerCAmelCase , atol=1E-4 ) )
295
0
import torch from torch import nn class snake_case__ (nn.Module ): """simple docstring""" def __init__( self , __lowercase , __lowercase , __lowercase , __lowercase , __lowercase=1 , __lowercase=False ) -> Union[str, Any]: """simple docstring""" super().__init__() a__ : int = n_token a__ : Union[str, Any] = d_embed a__ : Optional[int] = d_proj a__ : Union[str, Any] = cutoffs + [n_token] a__ : Optional[int] = [0] + self.cutoffs a__ : Optional[Any] = div_val a__ : Optional[Any] = self.cutoffs[0] a__ : Optional[Any] = len(self.cutoffs ) - 1 a__ : Tuple = self.shortlist_size + self.n_clusters if self.n_clusters > 0: a__ : Any = nn.Parameter(torch.zeros(self.n_clusters , self.d_embed ) ) a__ : int = nn.Parameter(torch.zeros(self.n_clusters ) ) a__ : List[Any] = nn.ModuleList() a__ : Optional[Any] = nn.ParameterList() if div_val == 1: for i in range(len(self.cutoffs ) ): if d_proj != d_embed: self.out_projs.append(nn.Parameter(torch.FloatTensor(__lowercase , __lowercase ) ) ) else: self.out_projs.append(__lowercase ) self.out_layers.append(nn.Linear(__lowercase , __lowercase ) ) else: for i in range(len(self.cutoffs ) ): a__ : str = self.cutoff_ends[i], self.cutoff_ends[i + 1] a__ : Union[str, Any] = d_embed // (div_val**i) self.out_projs.append(nn.Parameter(torch.FloatTensor(__lowercase , __lowercase ) ) ) self.out_layers.append(nn.Linear(__lowercase , r_idx - l_idx ) ) a__ : List[Any] = keep_order def SCREAMING_SNAKE_CASE__( self , __lowercase , __lowercase , __lowercase , __lowercase ) -> List[str]: """simple docstring""" if proj is None: a__ : List[str] = nn.functional.linear(__lowercase , __lowercase , bias=__lowercase ) else: # if CUDA_MAJOR <= 9 and CUDA_MINOR <= 1: a__ : Optional[int] = nn.functional.linear(__lowercase , proj.t().contiguous() ) a__ : int = nn.functional.linear(__lowercase , __lowercase , bias=__lowercase ) # else: # logit = torch.einsum('bd,de,ev->bv', (hidden, proj, weight.t())) # if bias is not None: # logit = logit + bias return logit def SCREAMING_SNAKE_CASE__( self , __lowercase , __lowercase=None , __lowercase=False ) -> Optional[int]: """simple docstring""" if labels is not None: # Shift so that tokens < n predict n a__ : Optional[Any] = hidden[..., :-1, :].contiguous() a__ : Dict = labels[..., 1:].contiguous() a__ : Tuple = hidden.view(-1 , hidden.size(-1 ) ) a__ : Dict = labels.view(-1 ) if hidden.size(0 ) != labels.size(0 ): raise RuntimeError("""Input and labels should have the same size in the batch dimension.""" ) else: a__ : Dict = hidden.view(-1 , hidden.size(-1 ) ) if self.n_clusters == 0: a__ : Optional[int] = self._compute_logit(__lowercase , self.out_layers[0].weight , self.out_layers[0].bias , self.out_projs[0] ) if labels is not None: a__ : List[Any] = labels != -1_0_0 a__ : Any = torch.zeros_like(__lowercase , dtype=hidden.dtype , device=hidden.device ) a__ : List[Any] = ( -nn.functional.log_softmax(__lowercase , dim=-1 )[mask].gather(1 , labels[mask].unsqueeze(1 ) ).squeeze(1 ) ) else: a__ : Optional[int] = nn.functional.log_softmax(__lowercase , dim=-1 ) else: # construct weights and biases a__ : Union[str, Any] = [], [] for i in range(len(self.cutoffs ) ): if self.div_val == 1: a__ : Tuple = self.cutoff_ends[i], self.cutoff_ends[i + 1] a__ : Any = self.out_layers[0].weight[l_idx:r_idx] a__ : Dict = self.out_layers[0].bias[l_idx:r_idx] else: a__ : int = self.out_layers[i].weight a__ : Tuple = self.out_layers[i].bias if i == 0: a__ : List[str] = torch.cat([weight_i, self.cluster_weight] , dim=0 ) a__ : Any = torch.cat([bias_i, self.cluster_bias] , dim=0 ) weights.append(__lowercase ) biases.append(__lowercase ) a__ : Optional[int] = weights[0], biases[0], self.out_projs[0] a__ : Optional[int] = self._compute_logit(__lowercase , __lowercase , __lowercase , __lowercase ) a__ : Union[str, Any] = nn.functional.log_softmax(__lowercase , dim=1 ) if labels is None: a__ : Dict = hidden.new_empty((head_logit.size(0 ), self.n_token) ) else: a__ : int = torch.zeros_like(__lowercase , dtype=hidden.dtype , device=hidden.device ) a__ : Any = 0 a__ : Optional[Any] = [0] + self.cutoffs for i in range(len(__lowercase ) - 1 ): a__ : Tuple = cutoff_values[i], cutoff_values[i + 1] if labels is not None: a__ : List[str] = (labels >= l_idx) & (labels < r_idx) a__ : Any = mask_i.nonzero().squeeze() if indices_i.numel() == 0: continue a__ : Dict = labels.index_select(0 , __lowercase ) - l_idx a__ : int = head_logprob.index_select(0 , __lowercase ) a__ : Tuple = hidden.index_select(0 , __lowercase ) else: a__ : List[Any] = hidden if i == 0: if labels is not None: a__ : Union[str, Any] = head_logprob_i.gather(1 , target_i[:, None] ).squeeze(1 ) else: a__ : Optional[int] = head_logprob[:, : self.cutoffs[0]] else: a__ : str = weights[i], biases[i], self.out_projs[i] a__ : List[str] = self._compute_logit(__lowercase , __lowercase , __lowercase , __lowercase ) a__ : List[str] = nn.functional.log_softmax(__lowercase , dim=1 ) a__ : List[str] = self.cutoffs[0] + i - 1 # No probability for the head cluster if labels is not None: a__ : Optional[int] = head_logprob_i[:, cluster_prob_idx] + tail_logprob_i.gather( 1 , target_i[:, None] ).squeeze(1 ) else: a__ : Optional[Any] = head_logprob[:, cluster_prob_idx, None] + tail_logprob_i a__ : str = logprob_i if labels is not None: if (hasattr(self , """keep_order""" ) and self.keep_order) or keep_order: out.index_copy_(0 , __lowercase , -logprob_i ) else: out[offset : offset + logprob_i.size(0 )].copy_(-logprob_i ) offset += logprob_i.size(0 ) return out def SCREAMING_SNAKE_CASE__( self , __lowercase ) -> Union[str, Any]: """simple docstring""" if self.n_clusters == 0: a__ : Union[str, Any] = self._compute_logit(__lowercase , self.out_layers[0].weight , self.out_layers[0].bias , self.out_projs[0] ) return nn.functional.log_softmax(__lowercase , dim=-1 ) else: # construct weights and biases a__ : Any = [], [] for i in range(len(self.cutoffs ) ): if self.div_val == 1: a__ : List[str] = self.cutoff_ends[i], self.cutoff_ends[i + 1] a__ : Dict = self.out_layers[0].weight[l_idx:r_idx] a__ : Any = self.out_layers[0].bias[l_idx:r_idx] else: a__ : List[Any] = self.out_layers[i].weight a__ : Any = self.out_layers[i].bias if i == 0: a__ : Dict = torch.cat([weight_i, self.cluster_weight] , dim=0 ) a__ : Tuple = torch.cat([bias_i, self.cluster_bias] , dim=0 ) weights.append(__lowercase ) biases.append(__lowercase ) a__ : List[str] = weights[0], biases[0], self.out_projs[0] a__ : Optional[Any] = self._compute_logit(__lowercase , __lowercase , __lowercase , __lowercase ) a__ : Tuple = hidden.new_empty((head_logit.size(0 ), self.n_token) ) a__ : int = nn.functional.log_softmax(__lowercase , dim=1 ) a__ : List[str] = [0] + self.cutoffs for i in range(len(__lowercase ) - 1 ): a__ : Union[str, Any] = cutoff_values[i], cutoff_values[i + 1] if i == 0: a__ : List[str] = head_logprob[:, : self.cutoffs[0]] else: a__ : Tuple = weights[i], biases[i], self.out_projs[i] a__ : Union[str, Any] = self._compute_logit(__lowercase , __lowercase , __lowercase , __lowercase ) a__ : Tuple = nn.functional.log_softmax(__lowercase , dim=1 ) a__ : List[str] = head_logprob[:, -i] + tail_logprob_i a__ : str = logprob_i return out
371
import numpy as np import torch from torch.utils.data import Dataset from utils import logger class snake_case__ (A__ ): """simple docstring""" def __init__( self , __lowercase , __lowercase ) -> int: """simple docstring""" a__ : Tuple = params a__ : str = np.array(__lowercase ) a__ : List[Any] = np.array([len(__lowercase ) for t in data] ) self.check() self.remove_long_sequences() self.remove_empty_sequences() self.remove_unknown_sequences() self.check() self.print_statistics() def __getitem__( self , __lowercase ) -> Any: """simple docstring""" return (self.token_ids[index], self.lengths[index]) def __len__( self ) -> Dict: """simple docstring""" return len(self.lengths ) def SCREAMING_SNAKE_CASE__( self ) -> Optional[int]: """simple docstring""" assert len(self.token_ids ) == len(self.lengths ) assert all(self.lengths[i] == len(self.token_ids[i] ) for i in range(len(self.lengths ) ) ) def SCREAMING_SNAKE_CASE__( self ) -> Tuple: """simple docstring""" a__ : int = self.params.max_model_input_size a__ : int = self.lengths > max_len logger.info(F'''Splitting {sum(__lowercase )} too long sequences.''' ) def divide_chunks(__lowercase , __lowercase ): return [l[i : i + n] for i in range(0 , len(__lowercase ) , __lowercase )] a__ : Any = [] a__ : Optional[int] = [] if self.params.mlm: a__ , a__ : Any = self.params.special_tok_ids["""cls_token"""], self.params.special_tok_ids["""sep_token"""] else: a__ , a__ : Dict = self.params.special_tok_ids["""bos_token"""], self.params.special_tok_ids["""eos_token"""] for seq_, len_ in zip(self.token_ids , self.lengths ): assert (seq_[0] == cls_id) and (seq_[-1] == sep_id), seq_ if len_ <= max_len: new_tok_ids.append(seq_ ) new_lengths.append(len_ ) else: a__ : int = [] for sub_s in divide_chunks(seq_ , max_len - 2 ): if sub_s[0] != cls_id: a__ : str = np.insert(__lowercase , 0 , __lowercase ) if sub_s[-1] != sep_id: a__ : List[str] = np.insert(__lowercase , len(__lowercase ) , __lowercase ) assert len(__lowercase ) <= max_len assert (sub_s[0] == cls_id) and (sub_s[-1] == sep_id), sub_s sub_seqs.append(__lowercase ) new_tok_ids.extend(__lowercase ) new_lengths.extend([len(__lowercase ) for l in sub_seqs] ) a__ : Optional[int] = np.array(__lowercase ) a__ : Any = np.array(__lowercase ) def SCREAMING_SNAKE_CASE__( self ) -> Optional[Any]: """simple docstring""" a__ : Union[str, Any] = len(self ) a__ : List[str] = self.lengths > 1_1 a__ : Dict = self.token_ids[indices] a__ : List[str] = self.lengths[indices] a__ : int = len(self ) logger.info(F'''Remove {init_size - new_size} too short (<=11 tokens) sequences.''' ) def SCREAMING_SNAKE_CASE__( self ) -> List[Any]: """simple docstring""" if "unk_token" not in self.params.special_tok_ids: return else: a__ : Union[str, Any] = self.params.special_tok_ids["""unk_token"""] a__ : List[Any] = len(self ) a__ : Optional[int] = np.array([np.count_nonzero(a == unk_token_id ) for a in self.token_ids] ) a__ : Optional[Any] = (unk_occs / self.lengths) < 0.5 a__ : Tuple = self.token_ids[indices] a__ : Union[str, Any] = self.lengths[indices] a__ : Tuple = len(self ) logger.info(F'''Remove {init_size - new_size} sequences with a high level of unknown tokens (50%).''' ) def SCREAMING_SNAKE_CASE__( self ) -> str: """simple docstring""" if not self.params.is_master: return logger.info(F'''{len(self )} sequences''' ) # data_len = sum(self.lengths) # nb_unique_tokens = len(Counter(list(chain(*self.token_ids)))) # logger.info(f'{data_len} tokens ({nb_unique_tokens} unique)') # unk_idx = self.params.special_tok_ids['unk_token'] # nb_unknown = sum([(t==unk_idx).sum() for t in self.token_ids]) # logger.info(f'{nb_unknown} unknown tokens (covering {100*nb_unknown/data_len:.2f}% of the data)') def SCREAMING_SNAKE_CASE__( self , __lowercase ) -> Optional[int]: """simple docstring""" a__ : Optional[int] = [t[0] for t in batch] a__ : Any = [t[1] for t in batch] assert len(__lowercase ) == len(__lowercase ) # Max for paddings a__ : List[Any] = max(__lowercase ) # Pad token ids if self.params.mlm: a__ : int = self.params.special_tok_ids["""pad_token"""] else: a__ : List[str] = self.params.special_tok_ids["""unk_token"""] a__ : int = [list(t.astype(__lowercase ) ) + [pad_idx] * (max_seq_len_ - len(__lowercase )) for t in token_ids] assert len(tk_ ) == len(__lowercase ) assert all(len(__lowercase ) == max_seq_len_ for t in tk_ ) a__ : List[Any] = torch.tensor(tk_ ) # (bs, max_seq_len_) a__ : Optional[int] = torch.tensor(__lowercase ) # (bs) return tk_t, lg_t
266
0
"""simple docstring""" import os import time from dataclasses import dataclass, field from enum import Enum from typing import Dict, List, Optional, Union import torch from filelock import FileLock from torch.utils.data import Dataset from ...models.auto.modeling_auto import MODEL_FOR_QUESTION_ANSWERING_MAPPING from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging from ..processors.squad import SquadFeatures, SquadVaProcessor, SquadVaProcessor, squad_convert_examples_to_features __snake_case = logging.get_logger(__name__) __snake_case = list(MODEL_FOR_QUESTION_ANSWERING_MAPPING.keys()) __snake_case = tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES) @dataclass class __lowerCamelCase : '''simple docstring''' A_ : str = field( default=a__ , metadata={'help': 'Model type selected in the list: ' + ', '.join(a__ )} ) A_ : str = field( default=a__ , metadata={'help': 'The input data dir. Should contain the .json files for the SQuAD task.'} ) A_ : int = field( default=128 , metadata={ 'help': ( 'The maximum total input sequence length after tokenization. Sequences longer ' 'than this will be truncated, sequences shorter will be padded.' ) } , ) A_ : int = field( default=128 , metadata={'help': 'When splitting up a long document into chunks, how much stride to take between chunks.'} , ) A_ : int = field( default=64 , metadata={ 'help': ( 'The maximum number of tokens for the question. Questions longer than this will ' 'be truncated to this length.' ) } , ) A_ : int = field( default=30 , metadata={ 'help': ( 'The maximum length of an answer that can be generated. This is needed because the start ' 'and end predictions are not conditioned on one another.' ) } , ) A_ : bool = field( default=a__ , metadata={'help': 'Overwrite the cached training and evaluation sets'} ) A_ : bool = field( default=a__ , metadata={'help': 'If true, the SQuAD examples contain some that do not have an answer.'} ) A_ : float = field( default=0.0 , metadata={'help': 'If null_score - best_non_null is greater than the threshold predict null.'} ) A_ : int = field( default=20 , metadata={'help': 'If null_score - best_non_null is greater than the threshold predict null.'} ) A_ : int = field( default=0 , metadata={ 'help': ( 'language id of input for language-specific xlm models (see' ' tokenization_xlm.PRETRAINED_INIT_CONFIGURATION)' ) } , ) A_ : int = field(default=1 , metadata={'help': 'multiple threads for converting example to features'} ) class __lowerCamelCase ( a__ ): '''simple docstring''' A_ : Optional[Any] = 'train' A_ : Union[str, Any] = 'dev' class __lowerCamelCase ( a__ ): '''simple docstring''' A_ : SquadDataTrainingArguments A_ : List[SquadFeatures] A_ : Split A_ : bool def __init__( self , __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase = None , __UpperCAmelCase = Split.train , __UpperCAmelCase = False , __UpperCAmelCase = None , __UpperCAmelCase = "pt" , ) -> Union[str, Any]: _a = args _a = is_language_sensitive _a = SquadVaProcessor() if args.version_2_with_negative else SquadVaProcessor() if isinstance(__UpperCAmelCase , __UpperCAmelCase ): try: _a = Split[mode] except KeyError: raise KeyError('''mode is not a valid split name''' ) _a = mode # Load data features from cache or dataset file _a = '''v2''' if args.version_2_with_negative else '''v1''' _a = os.path.join( cache_dir if cache_dir is not None else args.data_dir , F'cached_{mode.value}_{tokenizer.__class__.__name__}_{args.max_seq_length}_{version_tag}' , ) # Make sure only the first process in distributed training processes the dataset, # and the others will use the cache. _a = cached_features_file + '''.lock''' with FileLock(__UpperCAmelCase ): if os.path.exists(__UpperCAmelCase ) and not args.overwrite_cache: _a = time.time() _a = torch.load(__UpperCAmelCase ) # Legacy cache files have only features, while new cache files # will have dataset and examples also. _a = self.old_features['''features'''] _a = self.old_features.get('''dataset''' , __UpperCAmelCase ) _a = self.old_features.get('''examples''' , __UpperCAmelCase ) logger.info( F'Loading features from cached file {cached_features_file} [took %.3f s]' , time.time() - start ) if self.dataset is None or self.examples is None: logger.warning( F'Deleting cached file {cached_features_file} will allow dataset and examples to be cached in' ''' future run''' ) else: if mode == Split.dev: _a = self.processor.get_dev_examples(args.data_dir ) else: _a = self.processor.get_train_examples(args.data_dir ) _a , _a = squad_convert_examples_to_features( examples=self.examples , tokenizer=__UpperCAmelCase , max_seq_length=args.max_seq_length , doc_stride=args.doc_stride , max_query_length=args.max_query_length , is_training=mode == Split.train , threads=args.threads , return_dataset=__UpperCAmelCase , ) _a = time.time() torch.save( {'''features''': self.features, '''dataset''': self.dataset, '''examples''': self.examples} , __UpperCAmelCase , ) # ^ This seems to take a lot of time so I want to investigate why and how we can improve. logger.info( F'Saving features into cached file {cached_features_file} [took {time.time() - start:.3f} s]' ) def __len__( self ) -> Union[str, Any]: return len(self.features ) def __getitem__( self , __UpperCAmelCase ) -> Dict[str, torch.Tensor]: # Convert to Tensors and build dataset _a = self.features[i] _a = torch.tensor(feature.input_ids , dtype=torch.long ) _a = torch.tensor(feature.attention_mask , dtype=torch.long ) _a = torch.tensor(feature.token_type_ids , dtype=torch.long ) _a = torch.tensor(feature.cls_index , dtype=torch.long ) _a = torch.tensor(feature.p_mask , dtype=torch.float ) _a = torch.tensor(feature.is_impossible , dtype=torch.float ) _a = { '''input_ids''': input_ids, '''attention_mask''': attention_mask, '''token_type_ids''': token_type_ids, } if self.args.model_type in ["xlm", "roberta", "distilbert", "camembert"]: del inputs["token_type_ids"] if self.args.model_type in ["xlnet", "xlm"]: inputs.update({'''cls_index''': cls_index, '''p_mask''': p_mask} ) if self.args.version_2_with_negative: inputs.update({'''is_impossible''': is_impossible} ) if self.is_language_sensitive: inputs.update({'''langs''': (torch.ones(input_ids.shape , dtype=torch.intaa ) * self.args.lang_id)} ) if self.mode == Split.train: _a = torch.tensor(feature.start_position , dtype=torch.long ) _a = torch.tensor(feature.end_position , dtype=torch.long ) inputs.update({'''start_positions''': start_positions, '''end_positions''': end_positions} ) return inputs
320
"""simple docstring""" from __future__ import annotations def A_ ( _lowerCAmelCase : float, _lowerCAmelCase : float, _lowerCAmelCase : float, ): """simple docstring""" if (stress, tangential_force, area).count(0 ) != 1: raise ValueError('''You cannot supply more or less than 2 values''' ) elif stress < 0: raise ValueError('''Stress cannot be negative''' ) elif tangential_force < 0: raise ValueError('''Tangential Force cannot be negative''' ) elif area < 0: raise ValueError('''Area cannot be negative''' ) elif stress == 0: return ( "stress", tangential_force / area, ) elif tangential_force == 0: return ( "tangential_force", stress * area, ) else: return ( "area", tangential_force / stress, ) if __name__ == "__main__": import doctest doctest.testmod()
320
1
def __snake_case ( _lowerCAmelCase : Dict , _lowerCAmelCase : Union[str, Any] ) -> Union[str, Any]: A_ : Optional[int] = len(_lowerCAmelCase ) print("The following activities are selected:" ) # The first activity is always selected A_ : List[Any] = 0 print(_lowerCAmelCase , end="," ) # Consider rest of the activities for j in range(_lowerCAmelCase ): # If this activity has start time greater than # or equal to the finish time of previously # selected activity, then select it if start[j] >= finish[i]: print(_lowerCAmelCase , end="," ) A_ : Optional[int] = j if __name__ == "__main__": import doctest doctest.testmod() _lowerCAmelCase : Optional[Any] = [1, 3, 0, 5, 8, 5] _lowerCAmelCase : Dict = [2, 4, 6, 7, 9, 9] print_max_activities(start, finish)
366
import argparse import torch from transformers import ( SpeechTaConfig, SpeechTaFeatureExtractor, SpeechTaForSpeechToSpeech, SpeechTaForSpeechToText, SpeechTaForTextToSpeech, SpeechTaProcessor, SpeechTaTokenizer, logging, ) from transformers.tokenization_utils import AddedToken logging.set_verbosity_info() _lowerCAmelCase : Tuple = logging.get_logger('''transformers.models.speecht5''') _lowerCAmelCase : int = { '''speech_encoder_prenet.layer_norm''': '''speecht5.encoder.prenet.feature_projection.layer_norm''', '''speech_encoder_prenet.post_extract_proj''': '''speecht5.encoder.prenet.feature_projection.projection''', '''speech_encoder_prenet.pos_conv.0''': '''speecht5.encoder.prenet.pos_conv_embed.conv''', '''speech_encoder_prenet.mask_emb''': '''speecht5.encoder.prenet.masked_spec_embed''', } _lowerCAmelCase : str = { '''text_encoder_prenet.encoder_prenet.0''': '''speecht5.encoder.prenet.embed_tokens''', '''text_encoder_prenet.encoder_prenet.1.alpha''': '''speecht5.encoder.prenet.encode_positions.alpha''', } _lowerCAmelCase : int = { '''speech_decoder_prenet.decoder_prenet.0.0.prenet.0.0''': '''speecht5.decoder.prenet.layers.0''', '''speech_decoder_prenet.decoder_prenet.0.0.prenet.1.0''': '''speecht5.decoder.prenet.layers.1''', '''speech_decoder_prenet.decoder_prenet.0.1''': '''speecht5.decoder.prenet.final_layer''', '''speech_decoder_prenet.decoder_prenet.1.alpha''': '''speecht5.decoder.prenet.encode_positions.alpha''', '''speech_decoder_prenet.spkembs_layer.0''': '''speecht5.decoder.prenet.speaker_embeds_layer''', } _lowerCAmelCase : Union[str, Any] = { '''speech_decoder_postnet.feat_out''': '''speech_decoder_postnet.feat_out''', '''speech_decoder_postnet.prob_out''': '''speech_decoder_postnet.prob_out''', '''speech_decoder_postnet.postnet.postnet.0.0''': '''speech_decoder_postnet.layers.0.conv''', '''speech_decoder_postnet.postnet.postnet.0.1''': '''speech_decoder_postnet.layers.0.batch_norm''', '''speech_decoder_postnet.postnet.postnet.1.0''': '''speech_decoder_postnet.layers.1.conv''', '''speech_decoder_postnet.postnet.postnet.1.1''': '''speech_decoder_postnet.layers.1.batch_norm''', '''speech_decoder_postnet.postnet.postnet.2.0''': '''speech_decoder_postnet.layers.2.conv''', '''speech_decoder_postnet.postnet.postnet.2.1''': '''speech_decoder_postnet.layers.2.batch_norm''', '''speech_decoder_postnet.postnet.postnet.3.0''': '''speech_decoder_postnet.layers.3.conv''', '''speech_decoder_postnet.postnet.postnet.3.1''': '''speech_decoder_postnet.layers.3.batch_norm''', '''speech_decoder_postnet.postnet.postnet.4.0''': '''speech_decoder_postnet.layers.4.conv''', '''speech_decoder_postnet.postnet.postnet.4.1''': '''speech_decoder_postnet.layers.4.batch_norm''', } _lowerCAmelCase : Union[str, Any] = { '''text_decoder_prenet.embed_tokens''': '''speecht5.decoder.prenet.embed_tokens''', } _lowerCAmelCase : int = { '''text_decoder_postnet.output_projection''': '''text_decoder_postnet.lm_head''', } _lowerCAmelCase : Any = { '''encoder.layers.*.self_attn.k_proj''': '''speecht5.encoder.wrapped_encoder.layers.*.attention.k_proj''', '''encoder.layers.*.self_attn.v_proj''': '''speecht5.encoder.wrapped_encoder.layers.*.attention.v_proj''', '''encoder.layers.*.self_attn.q_proj''': '''speecht5.encoder.wrapped_encoder.layers.*.attention.q_proj''', '''encoder.layers.*.self_attn.out_proj''': '''speecht5.encoder.wrapped_encoder.layers.*.attention.out_proj''', '''encoder.layers.*.self_attn_layer_norm''': '''speecht5.encoder.wrapped_encoder.layers.*.layer_norm''', '''encoder.layers.*.fc1''': '''speecht5.encoder.wrapped_encoder.layers.*.feed_forward.intermediate_dense''', '''encoder.layers.*.fc2''': '''speecht5.encoder.wrapped_encoder.layers.*.feed_forward.output_dense''', '''encoder.layers.*.final_layer_norm''': '''speecht5.encoder.wrapped_encoder.layers.*.final_layer_norm''', '''encoder.layer_norm''': '''speecht5.encoder.wrapped_encoder.layer_norm''', '''encoder.pos_emb.pe_k''': '''speecht5.encoder.wrapped_encoder.embed_positions.pe_k''', } _lowerCAmelCase : List[str] = { '''decoder.layers.*.self_attn.k_proj''': '''speecht5.decoder.wrapped_decoder.layers.*.self_attn.k_proj''', '''decoder.layers.*.self_attn.v_proj''': '''speecht5.decoder.wrapped_decoder.layers.*.self_attn.v_proj''', '''decoder.layers.*.self_attn.q_proj''': '''speecht5.decoder.wrapped_decoder.layers.*.self_attn.q_proj''', '''decoder.layers.*.self_attn.out_proj''': '''speecht5.decoder.wrapped_decoder.layers.*.self_attn.out_proj''', '''decoder.layers.*.self_attn_layer_norm''': '''speecht5.decoder.wrapped_decoder.layers.*.self_attn_layer_norm''', '''decoder.layers.*.encoder_attn.k_proj''': '''speecht5.decoder.wrapped_decoder.layers.*.encoder_attn.k_proj''', '''decoder.layers.*.encoder_attn.v_proj''': '''speecht5.decoder.wrapped_decoder.layers.*.encoder_attn.v_proj''', '''decoder.layers.*.encoder_attn.q_proj''': '''speecht5.decoder.wrapped_decoder.layers.*.encoder_attn.q_proj''', '''decoder.layers.*.encoder_attn.out_proj''': '''speecht5.decoder.wrapped_decoder.layers.*.encoder_attn.out_proj''', '''decoder.layers.*.encoder_attn_layer_norm''': '''speecht5.decoder.wrapped_decoder.layers.*.encoder_attn_layer_norm''', '''decoder.layers.*.fc1''': '''speecht5.decoder.wrapped_decoder.layers.*.feed_forward.intermediate_dense''', '''decoder.layers.*.fc2''': '''speecht5.decoder.wrapped_decoder.layers.*.feed_forward.output_dense''', '''decoder.layers.*.final_layer_norm''': '''speecht5.decoder.wrapped_decoder.layers.*.final_layer_norm''', } _lowerCAmelCase : Optional[Any] = { **MAPPING_SPEECH_ENCODER_PRENET, **MAPPING_ENCODER, **MAPPING_DECODER, **MAPPING_TEXT_DECODER_PRENET, **MAPPING_TEXT_DECODER_POSTNET, } _lowerCAmelCase : Dict = { **MAPPING_TEXT_ENCODER_PRENET, **MAPPING_ENCODER, **MAPPING_DECODER, **MAPPING_SPEECH_DECODER_PRENET, **MAPPING_SPEECH_DECODER_POSTNET, } _lowerCAmelCase : Union[str, Any] = { **MAPPING_SPEECH_ENCODER_PRENET, **MAPPING_ENCODER, **MAPPING_DECODER, **MAPPING_SPEECH_DECODER_PRENET, **MAPPING_SPEECH_DECODER_POSTNET, } _lowerCAmelCase : Optional[Any] = [] _lowerCAmelCase : Tuple = [ '''encoder.version''', '''encoder.layers.*.norm_k.weight''', '''encoder.layers.*.norm_k.bias''', '''decoder.version''', '''decoder.layers.*.norm_k.weight''', '''decoder.layers.*.norm_k.bias''', '''decoder.pos_emb.pe_k''', '''speech_encoder_prenet.embed_positions._float_tensor''', '''text_decoder_prenet.embed_positions._float_tensor''', ] _lowerCAmelCase : Tuple = IGNORE_KEYS + [ '''encoder.proj''', '''text_encoder_prenet.*''', '''speech_decoder_prenet.*''', '''speech_decoder_postnet.*''', ] _lowerCAmelCase : int = IGNORE_KEYS + [ '''encoder.proj''', '''speech_encoder_prenet.*''', '''text_decoder_prenet.*''', '''text_decoder_postnet.*''', ] _lowerCAmelCase : Optional[int] = IGNORE_KEYS + [ '''encoder.proj''', '''text_encoder_prenet.*''', '''text_decoder_prenet.*''', '''text_decoder_postnet.*''', ] def __snake_case ( _lowerCAmelCase : int , _lowerCAmelCase : List[str] , _lowerCAmelCase : int , _lowerCAmelCase : Any , _lowerCAmelCase : List[str] ) -> Optional[Any]: for attribute in key.split("." ): A_ : List[Any] = getattr(_lowerCAmelCase , _lowerCAmelCase ) if weight_type is not None: A_ : Tuple = getattr(_lowerCAmelCase , _lowerCAmelCase ).shape else: A_ : List[Any] = hf_pointer.shape if hf_shape != value.shape: raise ValueError( f"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be" f" {value.shape} for {full_name}" ) if weight_type == "weight": A_ : Dict = value elif weight_type == "weight_g": A_ : int = value elif weight_type == "weight_v": A_ : str = value elif weight_type == "bias": A_ : int = value elif weight_type == "running_mean": A_ : str = value elif weight_type == "running_var": A_ : Any = value elif weight_type == "num_batches_tracked": A_ : str = value else: A_ : int = value logger.info(f"{key + ('.' + weight_type if weight_type is not None else '')} was initialized from {full_name}." ) def __snake_case ( _lowerCAmelCase : Optional[Any] , _lowerCAmelCase : int ) -> Union[str, Any]: for key in ignore_keys: if key.endswith(".*" ): if name.startswith(key[:-1] ): return True elif ".*." in key: A_ , A_ : Tuple = key.split(".*." ) if prefix in name and suffix in name: return True elif key in name: return True return False def __snake_case ( _lowerCAmelCase : int , _lowerCAmelCase : Tuple , _lowerCAmelCase : Optional[Any] ) -> Union[str, Any]: A_ : Tuple = [] if task == "s2t": A_ : Union[str, Any] = hf_model.speechta.encoder.prenet.feature_encoder A_ : str = MAPPING_S2T A_ : Union[str, Any] = IGNORE_KEYS_S2T elif task == "t2s": A_ : Optional[int] = None A_ : Dict = MAPPING_T2S A_ : Any = IGNORE_KEYS_T2S elif task == "s2s": A_ : Optional[int] = hf_model.speechta.encoder.prenet.feature_encoder A_ : Dict = MAPPING_S2S A_ : List[str] = IGNORE_KEYS_S2S else: raise ValueError(f"Unsupported task: {task}" ) for name, value in fairseq_dict.items(): if should_ignore(_lowerCAmelCase , _lowerCAmelCase ): logger.info(f"{name} was ignored" ) continue A_ : List[Any] = False if "conv_layers" in name: load_conv_layer( _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , hf_model.config.feat_extract_norm == "group" , ) A_ : Tuple = True else: for key, mapped_key in MAPPING.items(): # mapped_key = "speecht5." + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key if "*" in key: A_ , A_ : Optional[Any] = key.split(".*." ) if prefix in name and suffix in name: A_ : int = suffix # if key in name or key.split("w2v_model.")[-1] == name.split(".")[0]: if key in name: A_ : str = True if "*" in mapped_key: A_ : List[str] = name.split(_lowerCAmelCase )[0].split("." )[-2] A_ : Optional[int] = mapped_key.replace("*" , _lowerCAmelCase ) if "weight_g" in name: A_ : Union[str, Any] = "weight_g" elif "weight_v" in name: A_ : List[Any] = "weight_v" elif "bias" in name: A_ : Tuple = "bias" elif "weight" in name: A_ : List[Any] = "weight" elif "running_mean" in name: A_ : Union[str, Any] = "running_mean" elif "running_var" in name: A_ : Union[str, Any] = "running_var" elif "num_batches_tracked" in name: A_ : List[Any] = "num_batches_tracked" else: A_ : Optional[Any] = None set_recursively(_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase ) continue if not is_used: unused_weights.append(_lowerCAmelCase ) logger.warning(f"Unused weights: {unused_weights}" ) def __snake_case ( _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Tuple , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Optional[int] ) -> List[Any]: A_ : int = full_name.split("conv_layers." )[-1] A_ : Optional[Any] = name.split("." ) A_ : List[Any] = int(items[0] ) A_ : int = int(items[1] ) if type_id == 0: if "bias" in name: if value.shape != feature_extractor.conv_layers[layer_id].conv.bias.data.shape: raise ValueError( f"{full_name} has size {value.shape}, but" f" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found." ) A_ : Optional[int] = value logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}." ) elif "weight" in name: if value.shape != feature_extractor.conv_layers[layer_id].conv.weight.data.shape: raise ValueError( f"{full_name} has size {value.shape}, but" f" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found." ) A_ : Optional[Any] = value logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}." ) elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm): if "bias" in name: if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape: raise ValueError( f"{full_name} has size {value.shape}, but" f" {feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape} was found." ) A_ : Tuple = value logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}." ) elif "weight" in name: if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape: raise ValueError( f"{full_name} has size {value.shape}, but" f" {feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape} was found." ) A_ : Union[str, Any] = value logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}." ) else: unused_weights.append(_lowerCAmelCase ) @torch.no_grad() def __snake_case ( _lowerCAmelCase : Optional[Any] , _lowerCAmelCase : List[Any] , _lowerCAmelCase : List[str] , _lowerCAmelCase : str=None , _lowerCAmelCase : List[str]=None , _lowerCAmelCase : int=None , ) -> Optional[Any]: if config_path is not None: A_ : Dict = SpeechTaConfig.from_pretrained(_lowerCAmelCase ) else: A_ : Optional[int] = SpeechTaConfig() if task == "s2t": A_ : Optional[Any] = config.max_text_positions A_ : Optional[int] = SpeechTaForSpeechToText(_lowerCAmelCase ) elif task == "t2s": A_ : str = 1876 A_ : List[str] = 600 A_ : List[str] = config.max_speech_positions A_ : Tuple = SpeechTaForTextToSpeech(_lowerCAmelCase ) elif task == "s2s": A_ : Optional[int] = 1876 A_ : int = config.max_speech_positions A_ : Union[str, Any] = SpeechTaForSpeechToSpeech(_lowerCAmelCase ) else: raise ValueError(f"Unknown task name: {task}" ) if vocab_path: A_ : int = SpeechTaTokenizer(_lowerCAmelCase , model_max_length=config.max_text_positions ) # Mask token behaves like a normal word, i.e. include the space before it A_ : str = AddedToken("<mask>" , lstrip=_lowerCAmelCase , rstrip=_lowerCAmelCase ) A_ : int = mask_token tokenizer.add_special_tokens({"mask_token": mask_token} ) tokenizer.add_tokens(["<ctc_blank>"] ) A_ : int = SpeechTaFeatureExtractor() A_ : Optional[Any] = SpeechTaProcessor(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase ) processor.save_pretrained(_lowerCAmelCase ) A_ : Union[str, Any] = torch.load(_lowerCAmelCase ) recursively_load_weights(fairseq_checkpoint["model"] , _lowerCAmelCase , _lowerCAmelCase ) model.save_pretrained(_lowerCAmelCase ) if repo_id: print("Pushing to the hub..." ) processor.push_to_hub(_lowerCAmelCase ) model.push_to_hub(_lowerCAmelCase ) if __name__ == "__main__": _lowerCAmelCase : Tuple = argparse.ArgumentParser() parser.add_argument( '''--task''', default='''s2t''', type=str, help='''Type of the SpeechT5 model you\'d like to convert. Should be one of \'s2t\', \'t2s\', \'s2s\'.''', ) parser.add_argument('''--checkpoint_path''', required=True, default=None, type=str, help='''Path to fairseq checkpoint''') parser.add_argument('''--vocab_path''', default=None, type=str, help='''Path to SentencePiece model''') parser.add_argument('''--config_path''', default=None, type=str, help='''Path to hf config.json of model to convert''') parser.add_argument( '''--pytorch_dump_folder_path''', required=True, default=None, type=str, help='''Path to the output PyTorch model.''' ) parser.add_argument( '''--push_to_hub''', default=None, type=str, help='''Where to upload the converted model on the 🤗 hub.''' ) _lowerCAmelCase : Tuple = parser.parse_args() convert_speechta_checkpoint( args.task, args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.vocab_path, args.push_to_hub, )
70
0
'''simple docstring''' import os import re import warnings from shutil import copyfile from typing import List, Optional, Tuple from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import is_sentencepiece_available, logging if is_sentencepiece_available(): from .tokenization_ta import TaTokenizer else: UpperCAmelCase : List[Any] = None UpperCAmelCase : Optional[int] = logging.get_logger(__name__) UpperCAmelCase : Optional[Any] = {'vocab_file': 'spiece.model', 'tokenizer_file': 'tokenizer.json'} UpperCAmelCase : int = { 'vocab_file': { 't5-small': 'https://huggingface.co/t5-small/resolve/main/spiece.model', 't5-base': 'https://huggingface.co/t5-base/resolve/main/spiece.model', 't5-large': 'https://huggingface.co/t5-large/resolve/main/spiece.model', 't5-3b': 'https://huggingface.co/t5-3b/resolve/main/spiece.model', 't5-11b': 'https://huggingface.co/t5-11b/resolve/main/spiece.model', }, 'tokenizer_file': { 't5-small': 'https://huggingface.co/t5-small/resolve/main/tokenizer.json', 't5-base': 'https://huggingface.co/t5-base/resolve/main/tokenizer.json', 't5-large': 'https://huggingface.co/t5-large/resolve/main/tokenizer.json', 't5-3b': 'https://huggingface.co/t5-3b/resolve/main/tokenizer.json', 't5-11b': 'https://huggingface.co/t5-11b/resolve/main/tokenizer.json', }, } # TODO(PVP) - this should be removed in Transformers v5 UpperCAmelCase : Optional[int] = { 't5-small': 5_1_2, 't5-base': 5_1_2, 't5-large': 5_1_2, 't5-3b': 5_1_2, 't5-11b': 5_1_2, } class lowerCAmelCase__ ( a ): """simple docstring""" lowerCAmelCase__ = VOCAB_FILES_NAMES lowerCAmelCase__ = PRETRAINED_VOCAB_FILES_MAP lowerCAmelCase__ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowerCAmelCase__ = ["input_ids", "attention_mask"] lowerCAmelCase__ = TaTokenizer lowerCAmelCase__ = [] def __init__( self : Any , __SCREAMING_SNAKE_CASE : Dict=None , __SCREAMING_SNAKE_CASE : Union[str, Any]=None , __SCREAMING_SNAKE_CASE : List[str]="</s>" , __SCREAMING_SNAKE_CASE : Optional[int]="<unk>" , __SCREAMING_SNAKE_CASE : Optional[Any]="<pad>" , __SCREAMING_SNAKE_CASE : Tuple=100 , __SCREAMING_SNAKE_CASE : Tuple=None , **__SCREAMING_SNAKE_CASE : Dict , ) -> List[str]: """simple docstring""" if extra_ids > 0 and additional_special_tokens is None: __SCREAMING_SNAKE_CASE = [f'<extra_id_{i}>' for i in range(__SCREAMING_SNAKE_CASE )] elif extra_ids > 0 and additional_special_tokens is not None: # Check that we have the right number of extra special tokens __SCREAMING_SNAKE_CASE = len(set(filter(lambda __SCREAMING_SNAKE_CASE : bool("""extra_id_""" in str(__SCREAMING_SNAKE_CASE ) ) , __SCREAMING_SNAKE_CASE ) ) ) if extra_tokens != extra_ids: raise ValueError( f'Both extra_ids ({extra_ids}) and additional_special_tokens ({additional_special_tokens}) are' """ provided to T5Tokenizer. In this case the additional_special_tokens must include the extra_ids""" """ tokens""" ) super().__init__( __SCREAMING_SNAKE_CASE , tokenizer_file=__SCREAMING_SNAKE_CASE , eos_token=__SCREAMING_SNAKE_CASE , unk_token=__SCREAMING_SNAKE_CASE , pad_token=__SCREAMING_SNAKE_CASE , extra_ids=__SCREAMING_SNAKE_CASE , additional_special_tokens=__SCREAMING_SNAKE_CASE , **__SCREAMING_SNAKE_CASE , ) __SCREAMING_SNAKE_CASE = vocab_file __SCREAMING_SNAKE_CASE = False if not self.vocab_file else True __SCREAMING_SNAKE_CASE = extra_ids @staticmethod def UpperCAmelCase__ ( __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : Any ) -> Tuple: """simple docstring""" if pretrained_model_name_or_path in TaTokenizerFast.max_model_input_sizes: __SCREAMING_SNAKE_CASE = TaTokenizerFast.max_model_input_sizes[pretrained_model_name_or_path] if init_max_model_length is not None and init_max_model_length != max_model_length: return init_max_model_length elif init_max_model_length is None: warnings.warn( """This tokenizer was incorrectly instantiated with a model max length of""" f' {deprecated_max_model_length} which will be corrected in Transformers v5.\nFor now, this' """ behavior is kept to avoid breaking backwards compatibility when padding/encoding with""" """ `truncation is True`.\n- Be aware that you SHOULD NOT rely on""" f' {pretrained_model_name_or_path} automatically truncating your input to' f' {deprecated_max_model_length} when padding/encoding.\n- If you want to encode/pad to sequences' f' longer than {deprecated_max_model_length} you can either instantiate this tokenizer with' """ `model_max_length` or pass `max_length` when encoding/padding.\n- To avoid this warning, please""" """ instantiate this tokenizer with `model_max_length` set to your preferred value.""" , __SCREAMING_SNAKE_CASE , ) return max_model_length def UpperCAmelCase__ ( self : str , __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : Optional[str] = None ) -> Tuple[str]: """simple docstring""" if not self.can_save_slow_tokenizer: raise ValueError( """Your fast tokenizer does not have the necessary information to save the vocabulary for a slow """ """tokenizer.""" ) if not os.path.isdir(__SCREAMING_SNAKE_CASE ): logger.error(f'Vocabulary path ({save_directory}) should be a directory' ) return __SCREAMING_SNAKE_CASE = os.path.join( __SCREAMING_SNAKE_CASE , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(__SCREAMING_SNAKE_CASE ): copyfile(self.vocab_file , __SCREAMING_SNAKE_CASE ) logger.info(f'Copy vocab file to {out_vocab_file}' ) return (out_vocab_file,) def UpperCAmelCase__ ( self : Dict , __SCREAMING_SNAKE_CASE : List[int] , __SCREAMING_SNAKE_CASE : Optional[List[int]] = None ) -> List[int]: """simple docstring""" __SCREAMING_SNAKE_CASE = token_ids_a + [self.eos_token_id] if token_ids_a is None: return self.prefix_tokens + token_ids_a else: __SCREAMING_SNAKE_CASE = token_ids_a + [self.eos_token_id] return self.prefix_tokens + token_ids_a + token_ids_a def UpperCAmelCase__ ( self : str , __SCREAMING_SNAKE_CASE : List[int] , __SCREAMING_SNAKE_CASE : Optional[List[int]] = None ) -> List[int]: """simple docstring""" __SCREAMING_SNAKE_CASE = [self.eos_token_id] if token_ids_a is None: return len(token_ids_a + eos ) * [0] return len(token_ids_a + eos + token_ids_a + eos ) * [0] def UpperCAmelCase__ ( self : List[str] ) -> Dict: """simple docstring""" return list( set(filter(lambda __SCREAMING_SNAKE_CASE : bool(re.search(r"""<extra_id_\d+>""" , __SCREAMING_SNAKE_CASE ) ) is not None , self.additional_special_tokens ) ) ) def UpperCAmelCase__ ( self : Union[str, Any] ) -> Any: """simple docstring""" return [self.convert_tokens_to_ids(__SCREAMING_SNAKE_CASE ) for token in self.get_sentinel_tokens()]
267
'''simple docstring''' def a__ ( a__ , a__ ): """simple docstring""" __SCREAMING_SNAKE_CASE = int(a__ ) # Initialize Result __SCREAMING_SNAKE_CASE = [] # Traverse through all denomination for denomination in reversed(a__ ): # Find denominations while int(a__ ) >= int(a__ ): total_value -= int(a__ ) answer.append(a__ ) # Append the "answers" array return answer # Driver Code if __name__ == "__main__": UpperCAmelCase : Dict = [] UpperCAmelCase : List[str] = '0' if ( input('Do you want to enter your denominations ? (yY/n): ').strip().lower() == "y" ): UpperCAmelCase : List[str] = int(input('Enter the number of denominations you want to add: ').strip()) for i in range(0, n): denominations.append(int(input(f"""Denomination {i}: """).strip())) UpperCAmelCase : str = input('Enter the change you want to make in Indian Currency: ').strip() else: # All denominations of Indian Currency if user does not enter UpperCAmelCase : int = [1, 2, 5, 1_0, 2_0, 5_0, 1_0_0, 5_0_0, 2_0_0_0] UpperCAmelCase : Any = input('Enter the change you want to make: ').strip() if int(value) == 0 or int(value) < 0: print('The total value cannot be zero or negative.') else: print(f"""Following is minimal change for {value}: """) UpperCAmelCase : Any = find_minimum_change(denominations, value) # Print result for i in range(len(answer)): print(answer[i], end=' ')
267
1
import inspect import re from hashlib import shaaaa from typing import Dict, List from .arrow import arrow from .audiofolder import audiofolder from .csv import csv from .imagefolder import imagefolder from .json import json from .pandas import pandas from .parquet import parquet from .sql import sql # noqa F401 from .text import text def _A ( __magic_name__ ): lowercase__ = [] for line in lines: lowercase__ = re.sub(R"#.*" , "" , __magic_name__ ) # remove comments if line: filtered_lines.append(__magic_name__ ) lowercase__ = "\n".join(__magic_name__ ) # Make a hash from all this code lowercase__ = full_str.encode("utf-8" ) return shaaaa(__magic_name__ ).hexdigest() # get importable module names and hash for caching _snake_case = { """csv""": (csv.__name__, _hash_python_lines(inspect.getsource(csv).splitlines())), """json""": (json.__name__, _hash_python_lines(inspect.getsource(json).splitlines())), """pandas""": (pandas.__name__, _hash_python_lines(inspect.getsource(pandas).splitlines())), """parquet""": (parquet.__name__, _hash_python_lines(inspect.getsource(parquet).splitlines())), """arrow""": (arrow.__name__, _hash_python_lines(inspect.getsource(arrow).splitlines())), """text""": (text.__name__, _hash_python_lines(inspect.getsource(text).splitlines())), """imagefolder""": (imagefolder.__name__, _hash_python_lines(inspect.getsource(imagefolder).splitlines())), """audiofolder""": (audiofolder.__name__, _hash_python_lines(inspect.getsource(audiofolder).splitlines())), } # Used to infer the module to use based on the data files extensions _snake_case = { """.csv""": ("""csv""", {}), """.tsv""": ("""csv""", {"""sep""": """\t"""}), """.json""": ("""json""", {}), """.jsonl""": ("""json""", {}), """.parquet""": ("""parquet""", {}), """.arrow""": ("""arrow""", {}), """.txt""": ("""text""", {}), } _EXTENSION_TO_MODULE.update({ext: ("""imagefolder""", {}) for ext in imagefolder.ImageFolder.EXTENSIONS}) _EXTENSION_TO_MODULE.update({ext.upper(): ("""imagefolder""", {}) for ext in imagefolder.ImageFolder.EXTENSIONS}) _EXTENSION_TO_MODULE.update({ext: ("""audiofolder""", {}) for ext in audiofolder.AudioFolder.EXTENSIONS}) _EXTENSION_TO_MODULE.update({ext.upper(): ("""audiofolder""", {}) for ext in audiofolder.AudioFolder.EXTENSIONS}) _snake_case = {"""imagefolder""", """audiofolder"""} # Used to filter data files based on extensions given a module name _snake_case = {} for _ext, (_module, _) in _EXTENSION_TO_MODULE.items(): _MODULE_TO_EXTENSIONS.setdefault(_module, []).append(_ext) _MODULE_TO_EXTENSIONS["imagefolder"].append(""".zip""") _MODULE_TO_EXTENSIONS["audiofolder"].append(""".zip""")
360
from abc import ABC, abstractmethod from typing import Optional, Union from .. import Dataset, DatasetDict, Features, IterableDataset, IterableDatasetDict, NamedSplit from ..utils.typing import NestedDataStructureLike, PathLike class lowerCAmelCase ( lowercase_ ): def __init__( self :str , _lowercase :Optional[NestedDataStructureLike[PathLike]] = None , _lowercase :Optional[NamedSplit] = None , _lowercase :Optional[Features] = None , _lowercase :str = None , _lowercase :bool = False , _lowercase :bool = False , _lowercase :Optional[int] = None , **_lowercase :Tuple , ): '''simple docstring''' lowercase__ = path_or_paths lowercase__ = split if split or isinstance(_lowercase , _lowercase ) else "train" lowercase__ = features lowercase__ = cache_dir lowercase__ = keep_in_memory lowercase__ = streaming lowercase__ = num_proc lowercase__ = kwargs @abstractmethod def UpperCAmelCase ( self :Any ): '''simple docstring''' pass class lowerCAmelCase ( lowercase_ ): def __init__( self :List[Any] , _lowercase :Optional[Features] = None , _lowercase :str = None , _lowercase :bool = False , _lowercase :bool = False , _lowercase :Optional[int] = None , **_lowercase :Optional[int] , ): '''simple docstring''' lowercase__ = features lowercase__ = cache_dir lowercase__ = keep_in_memory lowercase__ = streaming lowercase__ = num_proc lowercase__ = kwargs @abstractmethod def UpperCAmelCase ( self :int ): '''simple docstring''' pass
201
0
from ..utils import DummyObject, requires_backends class __lowerCAmelCase ( metaclass=lowerCAmelCase_): _lowercase : Tuple = ["""torch""", """torchsde"""] def __init__( self , *lowerCAmelCase__ , **lowerCAmelCase__ ) -> Optional[Any]: '''simple docstring''' requires_backends(self , ["torch", "torchsde"] ) @classmethod def _lowercase ( cls , *lowerCAmelCase__ , **lowerCAmelCase__ ) -> Union[str, Any]: '''simple docstring''' requires_backends(cls , ["torch", "torchsde"] ) @classmethod def _lowercase ( cls , *lowerCAmelCase__ , **lowerCAmelCase__ ) -> Optional[Any]: '''simple docstring''' requires_backends(cls , ["torch", "torchsde"] )
95
import os import unittest from transformers.models.transfo_xl.tokenization_transfo_xl import VOCAB_FILES_NAMES, TransfoXLTokenizer from ...test_tokenization_common import TokenizerTesterMixin class snake_case__ ( lowerCAmelCase_ , unittest.TestCase ): """simple docstring""" _SCREAMING_SNAKE_CASE = TransfoXLTokenizer _SCREAMING_SNAKE_CASE = False _SCREAMING_SNAKE_CASE = False def lowercase_ ( self : Optional[int] ) ->Any: super().setUp() snake_case__ : Tuple = [ '<unk>', '[CLS]', '[SEP]', 'want', 'unwanted', 'wa', 'un', 'running', ',', 'low', 'l', ] snake_case__ : Any = os.path.join(self.tmpdirname, VOCAB_FILES_NAMES['vocab_file'] ) with open(self.vocab_file, 'w', encoding='utf-8' ) as vocab_writer: vocab_writer.write(''.join([x + '\n' for x in vocab_tokens] ) ) def lowercase_ ( self : Union[str, Any], **_snake_case : List[Any] ) ->Dict: snake_case__ : str = True return TransfoXLTokenizer.from_pretrained(self.tmpdirname, **_snake_case ) def lowercase_ ( self : Optional[Any], _snake_case : str ) ->Dict: snake_case__ : List[Any] = '<unk> UNwanted , running' snake_case__ : List[Any] = '<unk> unwanted, running' return input_text, output_text def lowercase_ ( self : List[Any] ) ->Tuple: snake_case__ : Dict = TransfoXLTokenizer(vocab_file=self.vocab_file, lower_case=_snake_case ) snake_case__ : str = tokenizer.tokenize('<unk> UNwanted , running' ) self.assertListEqual(_snake_case, ['<unk>', 'unwanted', ',', 'running'] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(_snake_case ), [0, 4, 8, 7] ) def lowercase_ ( self : List[str] ) ->List[Any]: snake_case__ : str = TransfoXLTokenizer(lower_case=_snake_case ) self.assertListEqual( tokenizer.tokenize(' \tHeLLo ! how \n Are yoU ? ' ), ['hello', '!', 'how', 'are', 'you', '?'] ) def lowercase_ ( self : Optional[int] ) ->Optional[Any]: snake_case__ : Optional[int] = TransfoXLTokenizer(lower_case=_snake_case ) self.assertListEqual( tokenizer.tokenize(' \tHeLLo ! how \n Are yoU ? ' ), ['HeLLo', '!', 'how', 'Are', 'yoU', '?'] ) def lowercase_ ( self : Optional[int] ) ->Union[str, Any]: snake_case__ : List[Any] = TransfoXLTokenizer(lower_case=_snake_case ) snake_case__ : Dict = 'Hello (bracket) and side-scrolled [and] Henry\'s $5,000 with 3.34 m. What\'s up!?' snake_case__ : List[Any] = [ 'Hello', '(', 'bracket', ')', 'and', 'side', '@-@', 'scrolled', '[', 'and', ']', 'Henry', '\'s', '$', '5', '@,@', '000', 'with', '3', '@.@', '34', 'm', '.', 'What', '\'s', 'up', '!', '?', ] self.assertListEqual(tokenizer.tokenize(_snake_case ), _snake_case ) self.assertEqual(tokenizer.convert_tokens_to_string(_snake_case ), _snake_case ) def lowercase_ ( self : Dict ) ->Any: snake_case__ : Dict = self.get_tokenizer() snake_case__ : Optional[Any] = len(_snake_case ) tokenizer.add_tokens(['new1', 'new2'] ) tokenizer.move_added_token('new1', 1 ) # Check that moved token is not copied (duplicate) self.assertEqual(len(_snake_case ), original_len + 2 ) # Check that token is moved to specified id self.assertEqual(tokenizer.encode('new1' ), [1] ) self.assertEqual(tokenizer.decode([1] ), 'new1' )
277
0
"""simple docstring""" import sys import warnings from os.path import abspath, dirname, join # allow having multiple repository checkouts and not needing to remember to rerun # 'pip install -e .[dev]' when switching between checkouts and running tests. lowercase__ : Dict = abspath(join(dirname(dirname(__file__)), '''src''')) sys.path.insert(1, git_repo_path) # silence FutureWarning warnings in tests since often we can't act on them until # they become normal warnings - i.e. the tests still need to test the current functionality warnings.simplefilter(action='''ignore''', category=FutureWarning) def __lowercase ( _a ): from diffusers.utils.testing_utils import pytest_addoption_shared pytest_addoption_shared(_a ) def __lowercase ( _a ): from diffusers.utils.testing_utils import pytest_terminal_summary_main snake_case_ : List[Any] = terminalreporter.config.getoption('''--make-reports''' ) if make_reports: pytest_terminal_summary_main(_a , id=_a )
360
"""simple docstring""" import math import sys def __lowercase ( _a ): if number != int(_a ): raise ValueError('''the value of input must be a natural number''' ) if number < 0: raise ValueError('''the value of input must not be a negative number''' ) if number == 0: return 1 snake_case_ : int = [-1] * (number + 1) snake_case_ : int = 0 for i in range(1 , number + 1 ): snake_case_ : Tuple = sys.maxsize snake_case_ : List[Any] = int(math.sqrt(_a ) ) for j in range(1 , root + 1 ): snake_case_ : Dict = 1 + answers[i - (j**2)] snake_case_ : int = min(_a , _a ) snake_case_ : Any = answer return answers[number] if __name__ == "__main__": import doctest doctest.testmod()
155
0
import argparse import json from typing import List from ltp import LTP from transformers.models.bert.tokenization_bert import BertTokenizer def a__ ( __UpperCamelCase ): # This defines a "chinese character" as anything in the CJK Unicode block: # https://en.wikipedia.org/wiki/CJK_Unified_Ideographs_(Unicode_block) # # Note that the CJK Unicode block is NOT all Japanese and Korean characters, # despite its name. The modern Korean Hangul alphabet is a different block, # as is Japanese Hiragana and Katakana. Those alphabets are used to write # space-separated words, so they are not treated specially and handled # like the all of the other languages. if ( (cp >= 0X4e00 and cp <= 0X9fff) or (cp >= 0X3400 and cp <= 0X4dbf) # or (cp >= 0X20000 and cp <= 0X2a6df) # or (cp >= 0X2a700 and cp <= 0X2b73f) # or (cp >= 0X2b740 and cp <= 0X2b81f) # or (cp >= 0X2b820 and cp <= 0X2ceaf) # or (cp >= 0Xf900 and cp <= 0Xfaff) or (cp >= 0X2f800 and cp <= 0X2fa1f) # ): # return True return False def a__ ( __UpperCamelCase ): # word like '180' or '身高' or '神' for char in word: SCREAMING_SNAKE_CASE_ = ord(__UpperCamelCase ) if not _is_chinese_char(__UpperCamelCase ): return 0 return 1 def a__ ( __UpperCamelCase ): SCREAMING_SNAKE_CASE_ = set() for token in tokens: SCREAMING_SNAKE_CASE_ = len(__UpperCamelCase ) > 1 and is_chinese(__UpperCamelCase ) if chinese_word: word_set.add(__UpperCamelCase ) SCREAMING_SNAKE_CASE_ = list(__UpperCamelCase ) return word_list def a__ ( __UpperCamelCase , __UpperCamelCase ): if not chinese_word_set: return bert_tokens SCREAMING_SNAKE_CASE_ = max([len(__UpperCamelCase ) for w in chinese_word_set] ) SCREAMING_SNAKE_CASE_ = bert_tokens SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ = 0, len(__UpperCamelCase ) while start < end: SCREAMING_SNAKE_CASE_ = True if is_chinese(bert_word[start] ): SCREAMING_SNAKE_CASE_ = min(end - start , __UpperCamelCase ) for i in range(__UpperCamelCase , 1 , -1 ): SCREAMING_SNAKE_CASE_ = "".join(bert_word[start : start + i] ) if whole_word in chinese_word_set: for j in range(start + 1 , start + i ): SCREAMING_SNAKE_CASE_ = "##" + bert_word[j] SCREAMING_SNAKE_CASE_ = start + i SCREAMING_SNAKE_CASE_ = False break if single_word: start += 1 return bert_word def a__ ( __UpperCamelCase , __UpperCamelCase , __UpperCamelCase ): SCREAMING_SNAKE_CASE_ = [] for i in range(0 , len(__UpperCamelCase ) , 1_0_0 ): SCREAMING_SNAKE_CASE_ = ltp_tokenizer.pipeline(lines[i : i + 1_0_0] , tasks=["cws"] ).cws SCREAMING_SNAKE_CASE_ = [get_chinese_word(__UpperCamelCase ) for r in res] ltp_res.extend(__UpperCamelCase ) assert len(__UpperCamelCase ) == len(__UpperCamelCase ) SCREAMING_SNAKE_CASE_ = [] for i in range(0 , len(__UpperCamelCase ) , 1_0_0 ): SCREAMING_SNAKE_CASE_ = bert_tokenizer(lines[i : i + 1_0_0] , add_special_tokens=__UpperCamelCase , truncation=__UpperCamelCase , max_length=5_1_2 ) bert_res.extend(res["input_ids"] ) assert len(__UpperCamelCase ) == len(__UpperCamelCase ) SCREAMING_SNAKE_CASE_ = [] for input_ids, chinese_word in zip(__UpperCamelCase , __UpperCamelCase ): SCREAMING_SNAKE_CASE_ = [] for id in input_ids: SCREAMING_SNAKE_CASE_ = bert_tokenizer._convert_id_to_token(__UpperCamelCase ) input_tokens.append(__UpperCamelCase ) SCREAMING_SNAKE_CASE_ = add_sub_symbol(__UpperCamelCase , __UpperCamelCase ) SCREAMING_SNAKE_CASE_ = [] # We only save pos of chinese subwords start with ##, which mean is part of a whole word. for i, token in enumerate(__UpperCamelCase ): if token[:2] == "##": SCREAMING_SNAKE_CASE_ = token[2:] # save chinese tokens' pos if len(__UpperCamelCase ) == 1 and _is_chinese_char(ord(__UpperCamelCase ) ): ref_id.append(__UpperCamelCase ) ref_ids.append(__UpperCamelCase ) assert len(__UpperCamelCase ) == len(__UpperCamelCase ) return ref_ids def a__ ( __UpperCamelCase ): # For Chinese (Ro)Bert, the best result is from : RoBERTa-wwm-ext (https://github.com/ymcui/Chinese-BERT-wwm) # If we want to fine-tune these model, we have to use same tokenizer : LTP (https://github.com/HIT-SCIR/ltp) with open(args.file_name , "r" , encoding="utf-8" ) as f: SCREAMING_SNAKE_CASE_ = f.readlines() SCREAMING_SNAKE_CASE_ = [line.strip() for line in data if len(__UpperCamelCase ) > 0 and not line.isspace()] # avoid delimiter like '\u2029' SCREAMING_SNAKE_CASE_ = LTP(args.ltp ) # faster in GPU device SCREAMING_SNAKE_CASE_ = BertTokenizer.from_pretrained(args.bert ) SCREAMING_SNAKE_CASE_ = prepare_ref(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) with open(args.save_path , "w" , encoding="utf-8" ) as f: SCREAMING_SNAKE_CASE_ = [json.dumps(__UpperCamelCase ) + "\n" for ref in ref_ids] f.writelines(__UpperCamelCase ) if __name__ == "__main__": A : Union[str, Any] = argparse.ArgumentParser(description="prepare_chinese_ref") parser.add_argument( "--file_name", required=False, type=str, default="./resources/chinese-demo.txt", help="file need process, same as training data in lm", ) parser.add_argument( "--ltp", required=False, type=str, default="./resources/ltp", help="resources for LTP tokenizer, usually a path", ) parser.add_argument( "--bert", required=False, type=str, default="./resources/robert", help="resources for Bert tokenizer", ) parser.add_argument( "--save_path", required=False, type=str, default="./resources/ref.txt", help="path to save res", ) A : int = parser.parse_args() main(args)
118
def a__ ( __UpperCamelCase = 1_0_0_0 ): SCREAMING_SNAKE_CASE_ = -1 SCREAMING_SNAKE_CASE_ = 0 for a in range(1 , n // 3 ): # Solving the two equations a**2+b**2=c**2 and a+b+c=N eliminating c SCREAMING_SNAKE_CASE_ = (n * n - 2 * a * n) // (2 * n - 2 * a) SCREAMING_SNAKE_CASE_ = n - a - b if c * c == (a * a + b * b): SCREAMING_SNAKE_CASE_ = a * b * c if candidate >= product: SCREAMING_SNAKE_CASE_ = candidate return product if __name__ == "__main__": print(f"{solution() = }")
118
1
'''simple docstring''' def A (__lowerCamelCase :int ): _lowerCAmelCase = [1] _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase = 0, 0, 0 _lowerCAmelCase = ugly_nums[ia] * 2 _lowerCAmelCase = ugly_nums[ia] * 3 _lowerCAmelCase = ugly_nums[ia] * 5 for _ in range(1 , __lowerCamelCase ): _lowerCAmelCase = min(__lowerCamelCase , __lowerCamelCase , __lowerCamelCase ) ugly_nums.append(__lowerCamelCase ) if next_num == next_a: ia += 1 _lowerCAmelCase = ugly_nums[ia] * 2 if next_num == next_a: ia += 1 _lowerCAmelCase = ugly_nums[ia] * 3 if next_num == next_a: ia += 1 _lowerCAmelCase = ugly_nums[ia] * 5 return ugly_nums[-1] if __name__ == "__main__": from doctest import testmod testmod(verbose=True) print(F"""{ugly_numbers(200) = }""")
364
'''simple docstring''' from typing import List, Optional, Tuple, Union import torch from ...schedulers import DDIMScheduler from ...utils import randn_tensor from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput class UpperCAmelCase_ ( _SCREAMING_SNAKE_CASE ): '''simple docstring''' def __init__( self , _lowercase , _lowercase ): """simple docstring""" super().__init__() # make sure scheduler can always be converted to DDIM _lowerCAmelCase = DDIMScheduler.from_config(scheduler.config ) self.register_modules(unet=_lowercase , scheduler=_lowercase ) @torch.no_grad() def __call__( self , _lowercase = 1 , _lowercase = None , _lowercase = 0.0 , _lowercase = 50 , _lowercase = None , _lowercase = "pil" , _lowercase = True , ): """simple docstring""" if isinstance(self.unet.config.sample_size , _lowercase ): _lowerCAmelCase = ( batch_size, self.unet.config.in_channels, self.unet.config.sample_size, self.unet.config.sample_size, ) else: _lowerCAmelCase = (batch_size, self.unet.config.in_channels, *self.unet.config.sample_size) if isinstance(_lowercase , _lowercase ) and len(_lowercase ) != batch_size: raise ValueError( F'You have passed a list of generators of length {len(_lowercase )}, but requested an effective batch' F' size of {batch_size}. Make sure the batch size matches the length of the generators.' ) _lowerCAmelCase = randn_tensor(_lowercase , generator=_lowercase , device=self.device , dtype=self.unet.dtype ) # set step values self.scheduler.set_timesteps(_lowercase ) for t in self.progress_bar(self.scheduler.timesteps ): # 1. predict noise model_output _lowerCAmelCase = self.unet(_lowercase , _lowercase ).sample # 2. predict previous mean of image x_t-1 and add variance depending on eta # eta corresponds to η in paper and should be between [0, 1] # do x_t -> x_t-1 _lowerCAmelCase = self.scheduler.step( _lowercase , _lowercase , _lowercase , eta=_lowercase , use_clipped_model_output=_lowercase , generator=_lowercase ).prev_sample _lowerCAmelCase = (image / 2 + 0.5).clamp(0 , 1 ) _lowerCAmelCase = image.cpu().permute(0 , 2 , 3 , 1 ).numpy() if output_type == "pil": _lowerCAmelCase = self.numpy_to_pil(_lowercase ) if not return_dict: return (image,) return ImagePipelineOutput(images=_lowercase )
229
0
"""simple docstring""" from typing import Dict, List, Optional, Union import numpy as np from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict from ...image_transforms import convert_to_rgb, normalize, rescale, resize, to_channel_dimension_format from ...image_utils import ( OPENAI_CLIP_MEAN, OPENAI_CLIP_STD, ChannelDimension, ImageInput, PILImageResampling, make_list_of_images, to_numpy_array, valid_images, ) from ...utils import TensorType, is_vision_available, logging if is_vision_available(): import PIL SCREAMING_SNAKE_CASE_ : int = logging.get_logger(__name__) class a ( _lowerCamelCase ): """simple docstring""" UpperCAmelCase = ["pixel_values"] def __init__( self: int , UpperCamelCase: bool = True , UpperCamelCase: Dict[str, int] = None , UpperCamelCase: PILImageResampling = PILImageResampling.BICUBIC , UpperCamelCase: bool = True , UpperCamelCase: Union[int, float] = 1 / 2_55 , UpperCamelCase: bool = True , UpperCamelCase: Optional[Union[float, List[float]]] = None , UpperCamelCase: Optional[Union[float, List[float]]] = None , UpperCamelCase: bool = True , **UpperCamelCase: Optional[Any] , ): """simple docstring""" super().__init__(**UpperCamelCase ) A__ = size if size is not None else {"""height""": 3_84, """width""": 3_84} A__ = get_size_dict(UpperCamelCase , default_to_square=UpperCamelCase ) A__ = do_resize A__ = size A__ = resample A__ = do_rescale A__ = rescale_factor A__ = do_normalize A__ = image_mean if image_mean is not None else OPENAI_CLIP_MEAN A__ = image_std if image_std is not None else OPENAI_CLIP_STD A__ = do_convert_rgb def UpperCamelCase ( self: Optional[Any] , UpperCamelCase: np.ndarray , UpperCamelCase: Dict[str, int] , UpperCamelCase: PILImageResampling = PILImageResampling.BICUBIC , UpperCamelCase: Optional[Union[str, ChannelDimension]] = None , **UpperCamelCase: Tuple , ): """simple docstring""" A__ = get_size_dict(UpperCamelCase , default_to_square=UpperCamelCase ) if "height" not in size or "width" not in size: raise ValueError(f"""The `size` dictionary must contain the keys `height` and `width`. Got {size.keys()}""" ) A__ = (size["""height"""], size["""width"""]) return resize(UpperCamelCase , size=UpperCamelCase , resample=UpperCamelCase , data_format=UpperCamelCase , **UpperCamelCase ) def UpperCamelCase ( self: List[Any] , UpperCamelCase: np.ndarray , UpperCamelCase: Union[int, float] , UpperCamelCase: Optional[Union[str, ChannelDimension]] = None , **UpperCamelCase: int , ): """simple docstring""" return rescale(UpperCamelCase , scale=UpperCamelCase , data_format=UpperCamelCase , **UpperCamelCase ) def UpperCamelCase ( self: Dict , UpperCamelCase: np.ndarray , UpperCamelCase: Union[float, List[float]] , UpperCamelCase: Union[float, List[float]] , UpperCamelCase: Optional[Union[str, ChannelDimension]] = None , **UpperCamelCase: int , ): """simple docstring""" return normalize(UpperCamelCase , mean=UpperCamelCase , std=UpperCamelCase , data_format=UpperCamelCase , **UpperCamelCase ) def UpperCamelCase ( self: Union[str, Any] , UpperCamelCase: ImageInput , UpperCamelCase: Optional[bool] = None , UpperCamelCase: Optional[Dict[str, int]] = None , UpperCamelCase: PILImageResampling = None , UpperCamelCase: Optional[bool] = None , UpperCamelCase: Optional[float] = None , UpperCamelCase: Optional[bool] = None , UpperCamelCase: Optional[Union[float, List[float]]] = None , UpperCamelCase: Optional[Union[float, List[float]]] = None , UpperCamelCase: Optional[Union[str, TensorType]] = None , UpperCamelCase: bool = None , UpperCamelCase: ChannelDimension = ChannelDimension.FIRST , **UpperCamelCase: List[Any] , ): """simple docstring""" A__ = do_resize if do_resize is not None else self.do_resize A__ = resample if resample is not None else self.resample A__ = do_rescale if do_rescale is not None else self.do_rescale A__ = rescale_factor if rescale_factor is not None else self.rescale_factor A__ = do_normalize if do_normalize is not None else self.do_normalize A__ = image_mean if image_mean is not None else self.image_mean A__ = image_std if image_std is not None else self.image_std A__ = do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb A__ = size if size is not None else self.size A__ = get_size_dict(UpperCamelCase , default_to_square=UpperCamelCase ) A__ = make_list_of_images(UpperCamelCase ) if not valid_images(UpperCamelCase ): raise ValueError( """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """ """torch.Tensor, tf.Tensor or jax.ndarray.""" ) if do_resize and size is None or resample is None: raise ValueError("""Size and resample must be specified if do_resize is True.""" ) if do_rescale and rescale_factor is None: raise ValueError("""Rescale factor must be specified if do_rescale is True.""" ) if do_normalize and (image_mean is None or image_std is None): raise ValueError("""Image mean and std must be specified if do_normalize is True.""" ) # PIL RGBA images are converted to RGB if do_convert_rgb: A__ = [convert_to_rgb(UpperCamelCase ) for image in images] # All transformations expect numpy arrays. A__ = [to_numpy_array(UpperCamelCase ) for image in images] if do_resize: A__ = [self.resize(image=UpperCamelCase , size=UpperCamelCase , resample=UpperCamelCase ) for image in images] if do_rescale: A__ = [self.rescale(image=UpperCamelCase , scale=UpperCamelCase ) for image in images] if do_normalize: A__ = [self.normalize(image=UpperCamelCase , mean=UpperCamelCase , std=UpperCamelCase ) for image in images] A__ = [to_channel_dimension_format(UpperCamelCase , UpperCamelCase ) for image in images] A__ = BatchFeature(data={"""pixel_values""": images} , tensor_type=UpperCamelCase ) return encoded_outputs
335
"""simple docstring""" import pytest from datasets.utils.sharding import _distribute_shards, _number_of_shards_in_gen_kwargs, _split_gen_kwargs @pytest.mark.parametrize( """kwargs, expected""" , [ ({"""num_shards""": 0, """max_num_jobs""": 1}, []), ({"""num_shards""": 10, """max_num_jobs""": 1}, [range(10 )]), ({"""num_shards""": 10, """max_num_jobs""": 10}, [range(UpperCAmelCase_ , i + 1 ) for i in range(10 )]), ({"""num_shards""": 1, """max_num_jobs""": 10}, [range(1 )]), ({"""num_shards""": 10, """max_num_jobs""": 3}, [range(0 , 4 ), range(4 , 7 ), range(7 , 10 )]), ({"""num_shards""": 3, """max_num_jobs""": 10}, [range(0 , 1 ), range(1 , 2 ), range(2 , 3 )]), ] , ) def _snake_case ( UpperCAmelCase_ : List[str] , UpperCAmelCase_ : int ): A__ = _distribute_shards(**UpperCAmelCase_ ) assert out == expected @pytest.mark.parametrize( """gen_kwargs, max_num_jobs, expected""" , [ ({"""foo""": 0}, 10, [{"""foo""": 0}]), ({"""shards""": [0, 1, 2, 3]}, 1, [{"""shards""": [0, 1, 2, 3]}]), ({"""shards""": [0, 1, 2, 3]}, 4, [{"""shards""": [0]}, {"""shards""": [1]}, {"""shards""": [2]}, {"""shards""": [3]}]), ({"""shards""": [0, 1]}, 4, [{"""shards""": [0]}, {"""shards""": [1]}]), ({"""shards""": [0, 1, 2, 3]}, 2, [{"""shards""": [0, 1]}, {"""shards""": [2, 3]}]), ] , ) def _snake_case ( UpperCAmelCase_ : str , UpperCAmelCase_ : Dict , UpperCAmelCase_ : List[Any] ): A__ = _split_gen_kwargs(UpperCAmelCase_ , UpperCAmelCase_ ) assert out == expected @pytest.mark.parametrize( """gen_kwargs, expected""" , [ ({"""foo""": 0}, 1), ({"""shards""": [0]}, 1), ({"""shards""": [0, 1, 2, 3]}, 4), ({"""shards""": [0, 1, 2, 3], """foo""": 0}, 4), ({"""shards""": [0, 1, 2, 3], """other""": (0, 1)}, 4), ({"""shards""": [0, 1, 2, 3], """shards2""": [0, 1]}, RuntimeError), ] , ) def _snake_case ( UpperCAmelCase_ : Optional[int] , UpperCAmelCase_ : Optional[int] ): if expected is RuntimeError: with pytest.raises(UpperCAmelCase_ ): _number_of_shards_in_gen_kwargs(UpperCAmelCase_ ) else: A__ = _number_of_shards_in_gen_kwargs(UpperCAmelCase_ ) assert out == expected
335
1
import os from shutil import copyfile from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging lowerCAmelCase__ = logging.get_logger(__name__) lowerCAmelCase__ = {'vocab_file': 'spiece.model'} lowerCAmelCase__ = { 'vocab_file': { 'bert_for_seq_generation': ( 'https://huggingface.co/google/bert_for_seq_generation_L-24_bbc_encoder/resolve/main/spiece.model' ), } } lowerCAmelCase__ = {'bert_for_seq_generation': 5_1_2} class snake_case__(_lowerCamelCase ): """simple docstring""" lowercase_ = VOCAB_FILES_NAMES lowercase_ = PRETRAINED_VOCAB_FILES_MAP lowercase_ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ = [] lowercase_ = ["""input_ids""", """attention_mask"""] def __init__( self : List[Any] , SCREAMING_SNAKE_CASE : Dict , SCREAMING_SNAKE_CASE : Dict="<s>" , SCREAMING_SNAKE_CASE : Optional[Any]="</s>" , SCREAMING_SNAKE_CASE : Union[str, Any]="<unk>" , SCREAMING_SNAKE_CASE : List[str]="<pad>" , SCREAMING_SNAKE_CASE : Optional[Any]="<::::>" , SCREAMING_SNAKE_CASE : Optional[Dict[str, Any]] = None , **SCREAMING_SNAKE_CASE : Optional[Any] , ): lowercase__ : Any = {} if sp_model_kwargs is None else sp_model_kwargs # Add extra_ids to the special token list super().__init__( bos_token=SCREAMING_SNAKE_CASE , eos_token=SCREAMING_SNAKE_CASE , unk_token=SCREAMING_SNAKE_CASE , pad_token=SCREAMING_SNAKE_CASE , sep_token=SCREAMING_SNAKE_CASE , sp_model_kwargs=self.sp_model_kwargs , **SCREAMING_SNAKE_CASE , ) lowercase__ : Any = vocab_file lowercase__ : Dict = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(SCREAMING_SNAKE_CASE ) @property def snake_case ( self : Any ): return self.sp_model.get_piece_size() def snake_case ( self : Optional[int] ): lowercase__ : List[str] = {self.convert_ids_to_tokens(SCREAMING_SNAKE_CASE ): i for i in range(self.vocab_size )} vocab.update(self.added_tokens_encoder ) return vocab def __getstate__( self : int ): lowercase__ : Dict = self.__dict__.copy() lowercase__ : List[str] = None return state def __setstate__( self : Optional[int] , SCREAMING_SNAKE_CASE : Optional[Any] ): lowercase__ : str = d # for backward compatibility if not hasattr(self , "sp_model_kwargs" ): lowercase__ : Dict = {} lowercase__ : int = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(self.vocab_file ) def snake_case ( self : Optional[int] , SCREAMING_SNAKE_CASE : str ): return self.sp_model.encode(SCREAMING_SNAKE_CASE , out_type=SCREAMING_SNAKE_CASE ) def snake_case ( self : str , SCREAMING_SNAKE_CASE : List[str] ): return self.sp_model.piece_to_id(SCREAMING_SNAKE_CASE ) def snake_case ( self : Tuple , SCREAMING_SNAKE_CASE : Tuple ): lowercase__ : str = self.sp_model.IdToPiece(SCREAMING_SNAKE_CASE ) return token def snake_case ( self : Dict , SCREAMING_SNAKE_CASE : int ): lowercase__ : Optional[int] = [] lowercase__ : str = "" for token in tokens: # make sure that special tokens are not decoded using sentencepiece model if token in self.all_special_tokens: out_string += self.sp_model.decode(SCREAMING_SNAKE_CASE ) + token lowercase__ : Dict = [] else: current_sub_tokens.append(SCREAMING_SNAKE_CASE ) out_string += self.sp_model.decode(SCREAMING_SNAKE_CASE ) return out_string.strip() def snake_case ( self : List[str] , SCREAMING_SNAKE_CASE : str , SCREAMING_SNAKE_CASE : Optional[str] = None ): if not os.path.isdir(SCREAMING_SNAKE_CASE ): logger.error(f"""Vocabulary path ({save_directory}) should be a directory""" ) return lowercase__ : int = os.path.join( SCREAMING_SNAKE_CASE , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(SCREAMING_SNAKE_CASE ) and os.path.isfile(self.vocab_file ): copyfile(self.vocab_file , SCREAMING_SNAKE_CASE ) elif not os.path.isfile(self.vocab_file ): with open(SCREAMING_SNAKE_CASE , "wb" ) as fi: lowercase__ : Optional[int] = self.sp_model.serialized_model_proto() fi.write(SCREAMING_SNAKE_CASE ) return (out_vocab_file,)
353
import os from argparse import ArgumentParser, Namespace from ..data import SingleSentenceClassificationProcessor as Processor from ..pipelines import TextClassificationPipeline from ..utils import is_tf_available, is_torch_available, logging from . import BaseTransformersCLICommand if not is_tf_available() and not is_torch_available(): raise RuntimeError('''At least one of PyTorch or TensorFlow 2.0+ should be installed to use CLI training''') # TF training parameters lowerCAmelCase__ = False lowerCAmelCase__ = False def __lowerCamelCase ( lowerCamelCase__ ): """simple docstring""" return TrainCommand(lowerCamelCase__ ) class snake_case__(_UpperCamelCase ): """simple docstring""" @staticmethod def snake_case ( SCREAMING_SNAKE_CASE : ArgumentParser ): lowercase__ : Optional[int] = parser.add_parser("train" , help="CLI tool to train a model on a task." ) train_parser.add_argument( "--train_data" , type=SCREAMING_SNAKE_CASE , required=SCREAMING_SNAKE_CASE , help="path to train (and optionally evaluation) dataset as a csv with tab separated labels and sentences." , ) train_parser.add_argument( "--column_label" , type=SCREAMING_SNAKE_CASE , default=0 , help="Column of the dataset csv file with example labels." ) train_parser.add_argument( "--column_text" , type=SCREAMING_SNAKE_CASE , default=1 , help="Column of the dataset csv file with example texts." ) train_parser.add_argument( "--column_id" , type=SCREAMING_SNAKE_CASE , default=2 , help="Column of the dataset csv file with example ids." ) train_parser.add_argument( "--skip_first_row" , action="store_true" , help="Skip the first row of the csv file (headers)." ) train_parser.add_argument("--validation_data" , type=SCREAMING_SNAKE_CASE , default="" , help="path to validation dataset." ) train_parser.add_argument( "--validation_split" , type=SCREAMING_SNAKE_CASE , default=0.1 , help="if validation dataset is not provided, fraction of train dataset to use as validation dataset." , ) train_parser.add_argument("--output" , type=SCREAMING_SNAKE_CASE , default="./" , help="path to saved the trained model." ) train_parser.add_argument( "--task" , type=SCREAMING_SNAKE_CASE , default="text_classification" , help="Task to train the model on." ) train_parser.add_argument( "--model" , type=SCREAMING_SNAKE_CASE , default="bert-base-uncased" , help="Model's name or path to stored model." ) train_parser.add_argument("--train_batch_size" , type=SCREAMING_SNAKE_CASE , default=32 , help="Batch size for training." ) train_parser.add_argument("--valid_batch_size" , type=SCREAMING_SNAKE_CASE , default=64 , help="Batch size for validation." ) train_parser.add_argument("--learning_rate" , type=SCREAMING_SNAKE_CASE , default=3E-5 , help="Learning rate." ) train_parser.add_argument("--adam_epsilon" , type=SCREAMING_SNAKE_CASE , default=1E-0_8 , help="Epsilon for Adam optimizer." ) train_parser.set_defaults(func=SCREAMING_SNAKE_CASE ) def __init__( self : int , SCREAMING_SNAKE_CASE : Namespace ): lowercase__ : int = logging.get_logger("transformers-cli/training" ) lowercase__ : List[Any] = "tf" if is_tf_available() else "torch" os.makedirs(args.output , exist_ok=SCREAMING_SNAKE_CASE ) lowercase__ : Optional[Any] = args.output lowercase__ : Union[str, Any] = args.column_label lowercase__ : Optional[int] = args.column_text lowercase__ : Optional[int] = args.column_id self.logger.info(f"""Loading {args.task} pipeline for {args.model}""" ) if args.task == "text_classification": lowercase__ : int = TextClassificationPipeline.from_pretrained(args.model ) elif args.task == "token_classification": raise NotImplementedError elif args.task == "question_answering": raise NotImplementedError self.logger.info(f"""Loading dataset from {args.train_data}""" ) lowercase__ : List[str] = Processor.create_from_csv( args.train_data , column_label=args.column_label , column_text=args.column_text , column_id=args.column_id , skip_first_row=args.skip_first_row , ) lowercase__ : Union[str, Any] = None if args.validation_data: self.logger.info(f"""Loading validation dataset from {args.validation_data}""" ) lowercase__ : Optional[int] = Processor.create_from_csv( args.validation_data , column_label=args.column_label , column_text=args.column_text , column_id=args.column_id , skip_first_row=args.skip_first_row , ) lowercase__ : Dict = args.validation_split lowercase__ : List[str] = args.train_batch_size lowercase__ : Any = args.valid_batch_size lowercase__ : Optional[int] = args.learning_rate lowercase__ : int = args.adam_epsilon def snake_case ( self : Dict ): if self.framework == "tf": return self.run_tf() return self.run_torch() def snake_case ( self : Union[str, Any] ): raise NotImplementedError def snake_case ( self : Union[str, Any] ): self.pipeline.fit( self.train_dataset , validation_data=self.valid_dataset , validation_split=self.validation_split , learning_rate=self.learning_rate , adam_epsilon=self.adam_epsilon , train_batch_size=self.train_batch_size , valid_batch_size=self.valid_batch_size , ) # Save trained pipeline self.pipeline.save_pretrained(self.output )
121
0
from ...configuration_utils import PretrainedConfig from ...utils import logging _lowerCamelCase : Tuple = logging.get_logger(__name__) _lowerCamelCase : Optional[Any] = { "sayakpaul/vit-msn-base": "https://huggingface.co/sayakpaul/vit-msn-base/resolve/main/config.json", # See all ViT MSN models at https://huggingface.co/models?filter=vit_msn } class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = """vit_msn""" def __init__( self : Tuple, __A : List[str]=7_6_8, __A : List[str]=1_2, __A : Dict=1_2, __A : Any=3_0_7_2, __A : Union[str, Any]="gelu", __A : Optional[Any]=0.0, __A : Tuple=0.0, __A : Tuple=0.0_2, __A : Optional[int]=1E-06, __A : Optional[Any]=2_2_4, __A : Optional[Any]=1_6, __A : int=3, __A : Union[str, Any]=True, **__A : int, ): super().__init__(**__A ) UpperCAmelCase : Union[str, Any] = hidden_size UpperCAmelCase : List[str] = num_hidden_layers UpperCAmelCase : List[str] = num_attention_heads UpperCAmelCase : int = intermediate_size UpperCAmelCase : str = hidden_act UpperCAmelCase : str = hidden_dropout_prob UpperCAmelCase : Optional[Any] = attention_probs_dropout_prob UpperCAmelCase : List[str] = initializer_range UpperCAmelCase : Optional[int] = layer_norm_eps UpperCAmelCase : Optional[int] = image_size UpperCAmelCase : Tuple = patch_size UpperCAmelCase : str = num_channels UpperCAmelCase : List[str] = qkv_bias
336
def a__ ( UpperCAmelCase : List[Any] , UpperCAmelCase : Optional[int] ) -> Optional[Any]: UpperCAmelCase : List[str] = 0 UpperCAmelCase : List[Any] = len(UpperCAmelCase ) - 1 while left <= right: # avoid divided by 0 during interpolation if sorted_collection[left] == sorted_collection[right]: if sorted_collection[left] == item: return left else: return None UpperCAmelCase : Optional[int] = left + ((item - sorted_collection[left]) * (right - left)) // ( sorted_collection[right] - sorted_collection[left] ) # out of range check if point < 0 or point >= len(UpperCAmelCase ): return None UpperCAmelCase : Optional[Any] = sorted_collection[point] if current_item == item: return point else: if point < left: UpperCAmelCase : Any = left UpperCAmelCase : List[str] = point elif point > right: UpperCAmelCase : Any = right UpperCAmelCase : List[str] = point else: if item < current_item: UpperCAmelCase : Optional[int] = point - 1 else: UpperCAmelCase : str = point + 1 return None def a__ ( UpperCAmelCase : Optional[Any] , UpperCAmelCase : int , UpperCAmelCase : str , UpperCAmelCase : Union[str, Any] ) -> Dict: # avoid divided by 0 during interpolation if sorted_collection[left] == sorted_collection[right]: if sorted_collection[left] == item: return left else: return None UpperCAmelCase : List[str] = left + ((item - sorted_collection[left]) * (right - left)) // ( sorted_collection[right] - sorted_collection[left] ) # out of range check if point < 0 or point >= len(UpperCAmelCase ): return None if sorted_collection[point] == item: return point elif point < left: return interpolation_search_by_recursion(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) elif point > right: return interpolation_search_by_recursion(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) else: if sorted_collection[point] > item: return interpolation_search_by_recursion( UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , point - 1 ) else: return interpolation_search_by_recursion( UpperCAmelCase , UpperCAmelCase , point + 1 , UpperCAmelCase ) def a__ ( UpperCAmelCase : Union[str, Any] ) -> int: if collection != sorted(UpperCAmelCase ): raise ValueError('''Collection must be ascending sorted''' ) return True if __name__ == "__main__": import sys _lowerCamelCase : Optional[int] = 0 if debug == 1: _lowerCamelCase : Dict = [1_0, 3_0, 4_0, 4_5, 5_0, 6_6, 7_7, 9_3] try: __assert_sorted(collection) except ValueError: sys.exit("Sequence must be ascending sorted to apply interpolation search") _lowerCamelCase : List[Any] = 6_7 _lowerCamelCase : Optional[Any] = interpolation_search(collection, target) if result is not None: print(f"""{target} found at positions: {result}""") else: print("Not found")
336
1
"""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 _SCREAMING_SNAKE_CASE ( unittest.TestCase ): def __init__( self , __A , __A=13 , __A=7 , __A=True , __A=True , __A=True , __A=True , __A=99 , __A=32 , __A=5 , __A=4 , __A=37 , __A="gelu" , __A=0.1 , __A=0.1 , __A=512 , __A=16 , __A=2 , __A=0.0_2 , __A=4 , ) -> int: lowerCAmelCase_ :Optional[Any] = parent lowerCAmelCase_ :Any = batch_size lowerCAmelCase_ :Optional[Any] = seq_length lowerCAmelCase_ :Optional[int] = is_training lowerCAmelCase_ :Optional[Any] = use_attention_mask lowerCAmelCase_ :Optional[int] = use_token_type_ids lowerCAmelCase_ :int = use_labels lowerCAmelCase_ :Union[str, Any] = vocab_size lowerCAmelCase_ :Optional[int] = hidden_size lowerCAmelCase_ :Tuple = num_hidden_layers lowerCAmelCase_ :Tuple = num_attention_heads lowerCAmelCase_ :Dict = intermediate_size lowerCAmelCase_ :Tuple = hidden_act lowerCAmelCase_ :Optional[Any] = hidden_dropout_prob lowerCAmelCase_ :Optional[Any] = attention_probs_dropout_prob lowerCAmelCase_ :Dict = max_position_embeddings lowerCAmelCase_ :Optional[Any] = type_vocab_size lowerCAmelCase_ :str = type_sequence_label_size lowerCAmelCase_ :List[str] = initializer_range lowerCAmelCase_ :int = num_choices def __lowerCAmelCase ( self ) -> Union[str, Any]: lowerCAmelCase_ :int = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) lowerCAmelCase_ :Dict = None if self.use_attention_mask: lowerCAmelCase_ :Any = random_attention_mask([self.batch_size, self.seq_length] ) lowerCAmelCase_ :str = 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_=__A , ) return config, input_ids, attention_mask def __lowerCAmelCase ( self ) -> str: lowerCAmelCase_ :Tuple = self.prepare_config_and_inputs() lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ :List[str] = config_and_inputs lowerCAmelCase_ :Optional[Any] = {"""input_ids""": input_ids, """attention_mask""": attention_mask} return config, inputs_dict @require_flax class _SCREAMING_SNAKE_CASE ( A__ , unittest.TestCase ): UpperCAmelCase_ :Tuple = ( ( FlaxDistilBertModel, FlaxDistilBertForMaskedLM, FlaxDistilBertForMultipleChoice, FlaxDistilBertForQuestionAnswering, FlaxDistilBertForSequenceClassification, FlaxDistilBertForTokenClassification, FlaxDistilBertForQuestionAnswering, ) if is_flax_available() else () ) def __lowerCAmelCase ( self ) -> Tuple: lowerCAmelCase_ :str = FlaxDistilBertModelTester(self ) @slow def __lowerCAmelCase ( self ) -> Dict: for model_class_name in self.all_model_classes: lowerCAmelCase_ :Dict = model_class_name.from_pretrained("""distilbert-base-uncased""" ) lowerCAmelCase_ :str = model(np.ones((1, 1) ) ) self.assertIsNotNone(__A ) @require_flax class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): @slow def __lowerCAmelCase ( self ) -> List[Any]: lowerCAmelCase_ :List[str] = FlaxDistilBertModel.from_pretrained("""distilbert-base-uncased""" ) lowerCAmelCase_ :List[Any] = np.array([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]] ) lowerCAmelCase_ :List[str] = np.array([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] ) lowerCAmelCase_ :List[Any] = model(__A , attention_mask=__A )[0] lowerCAmelCase_ :List[Any] = (1, 11, 768) self.assertEqual(output.shape , __A ) lowerCAmelCase_ :Tuple = np.array([[[-0.1_6_3_9, 0.3_2_9_9, 0.1_6_4_8], [-0.1_7_4_6, 0.3_2_8_9, 0.1_7_1_0], [-0.1_8_8_4, 0.3_3_5_7, 0.1_8_1_0]]] ) self.assertTrue(jnp.allclose(output[:, 1:4, 1:4] , __A , atol=1E-4 ) )
1
"""simple docstring""" def _snake_case ( lowercase__ : int = 5_0 ) -> int: '''simple docstring''' lowerCAmelCase_ :int = [1] * (length + 1) for row_length in range(3 , length + 1 ): for block_length in range(3 , row_length + 1 ): for block_start in range(row_length - block_length ): ways_number[row_length] += ways_number[ row_length - block_start - block_length - 1 ] ways_number[row_length] += 1 return ways_number[length] if __name__ == "__main__": print(F"""{solution() = }""")
1
1
import functools def UpperCamelCase (lowercase_: list[int] , lowercase_: list[int] ) -> int: # Validation if not isinstance(_lowerCamelCase , _lowerCamelCase ) or not all(isinstance(_lowerCamelCase , _lowerCamelCase ) for day in days ): raise ValueError("""The parameter days should be a list of integers""" ) if len(_lowerCamelCase ) != 3 or not all(isinstance(_lowerCamelCase , _lowerCamelCase ) for cost in costs ): raise ValueError("""The parameter costs should be a list of three integers""" ) if len(_lowerCamelCase ) == 0: return 0 if min(_lowerCamelCase ) <= 0: raise ValueError("""All days elements should be greater than 0""" ) if max(_lowerCamelCase ) >= 366: raise ValueError("""All days elements should be less than 366""" ) A__ : int = set(_lowerCamelCase ) @functools.cache def dynamic_programming(lowercase_: int ) -> int: if index > 365: return 0 if index not in days_set: return dynamic_programming(index + 1 ) return min( costs[0] + dynamic_programming(index + 1 ) , costs[1] + dynamic_programming(index + 7 ) , costs[2] + dynamic_programming(index + 30 ) , ) return dynamic_programming(1 ) if __name__ == "__main__": import doctest doctest.testmod()
192
"""simple docstring""" import os import unittest from transformers import MobileBertTokenizer, MobileBertTokenizerFast from transformers.models.bert.tokenization_bert import ( VOCAB_FILES_NAMES, BasicTokenizer, WordpieceTokenizer, _is_control, _is_punctuation, _is_whitespace, ) from transformers.testing_utils import require_tokenizers, slow from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english @require_tokenizers class a ( __snake_case , unittest.TestCase ): SCREAMING_SNAKE_CASE : List[str] = MobileBertTokenizer SCREAMING_SNAKE_CASE : int = MobileBertTokenizerFast SCREAMING_SNAKE_CASE : Union[str, Any] = True SCREAMING_SNAKE_CASE : Optional[Any] = True SCREAMING_SNAKE_CASE : Dict = filter_non_english SCREAMING_SNAKE_CASE : str = """google/mobilebert-uncased""" def UpperCamelCase ( self : List[str] ) -> Dict: super().setUp() lowerCamelCase_ = [ '[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing', ',', 'low', 'lowest', ] lowerCamelCase_ = 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] ) ) lowerCamelCase_ = [ (tokenizer_def[0], self.pre_trained_model_path, tokenizer_def[2]) # else the 'google/' prefix is stripped for tokenizer_def in self.tokenizers_list ] def UpperCamelCase ( self : List[Any] , __SCREAMING_SNAKE_CASE : Union[str, Any] ) -> int: lowerCamelCase_ = 'UNwant\u00E9d,running' lowerCamelCase_ = 'unwanted, running' return input_text, output_text def UpperCamelCase ( self : Dict ) -> Any: lowerCamelCase_ = self.tokenizer_class(self.vocab_file ) lowerCamelCase_ = tokenizer.tokenize('UNwant\u00E9d,running' ) self.assertListEqual(__SCREAMING_SNAKE_CASE , ['un', '##want', '##ed', ',', 'runn', '##ing'] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(__SCREAMING_SNAKE_CASE ) , [9, 6, 7, 12, 10, 11] ) def UpperCamelCase ( self : Dict ) -> Dict: if not self.test_rust_tokenizer: return lowerCamelCase_ = self.get_tokenizer() lowerCamelCase_ = self.get_rust_tokenizer() lowerCamelCase_ = 'UNwant\u00E9d,running' lowerCamelCase_ = tokenizer.tokenize(__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = rust_tokenizer.tokenize(__SCREAMING_SNAKE_CASE ) self.assertListEqual(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) lowerCamelCase_ = tokenizer.encode(__SCREAMING_SNAKE_CASE , add_special_tokens=__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = rust_tokenizer.encode(__SCREAMING_SNAKE_CASE , add_special_tokens=__SCREAMING_SNAKE_CASE ) self.assertListEqual(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) lowerCamelCase_ = self.get_rust_tokenizer() lowerCamelCase_ = tokenizer.encode(__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = rust_tokenizer.encode(__SCREAMING_SNAKE_CASE ) self.assertListEqual(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) # With lower casing lowerCamelCase_ = self.get_tokenizer(do_lower_case=__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = self.get_rust_tokenizer(do_lower_case=__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = 'UNwant\u00E9d,running' lowerCamelCase_ = tokenizer.tokenize(__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = rust_tokenizer.tokenize(__SCREAMING_SNAKE_CASE ) self.assertListEqual(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) lowerCamelCase_ = tokenizer.encode(__SCREAMING_SNAKE_CASE , add_special_tokens=__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = rust_tokenizer.encode(__SCREAMING_SNAKE_CASE , add_special_tokens=__SCREAMING_SNAKE_CASE ) self.assertListEqual(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) lowerCamelCase_ = self.get_rust_tokenizer() lowerCamelCase_ = tokenizer.encode(__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = rust_tokenizer.encode(__SCREAMING_SNAKE_CASE ) self.assertListEqual(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) def UpperCamelCase ( self : List[str] ) -> str: lowerCamelCase_ = BasicTokenizer() self.assertListEqual(tokenizer.tokenize('ah\u535A\u63A8zz' ) , ['ah', '\u535A', '\u63A8', 'zz'] ) def UpperCamelCase ( self : List[Any] ) -> Optional[int]: lowerCamelCase_ = BasicTokenizer(do_lower_case=__SCREAMING_SNAKE_CASE ) self.assertListEqual( tokenizer.tokenize(' \tHeLLo!how \n Are yoU? ' ) , ['hello', '!', 'how', 'are', 'you', '?'] ) self.assertListEqual(tokenizer.tokenize('H\u00E9llo' ) , ['hello'] ) def UpperCamelCase ( self : Any ) -> Any: lowerCamelCase_ = BasicTokenizer(do_lower_case=__SCREAMING_SNAKE_CASE , strip_accents=__SCREAMING_SNAKE_CASE ) self.assertListEqual( tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['hällo', '!', 'how', 'are', 'you', '?'] ) self.assertListEqual(tokenizer.tokenize('H\u00E9llo' ) , ['h\u00E9llo'] ) def UpperCamelCase ( self : Tuple ) -> Union[str, Any]: lowerCamelCase_ = BasicTokenizer(do_lower_case=__SCREAMING_SNAKE_CASE , strip_accents=__SCREAMING_SNAKE_CASE ) self.assertListEqual( tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['hallo', '!', 'how', 'are', 'you', '?'] ) self.assertListEqual(tokenizer.tokenize('H\u00E9llo' ) , ['hello'] ) def UpperCamelCase ( self : Tuple ) -> List[str]: lowerCamelCase_ = BasicTokenizer(do_lower_case=__SCREAMING_SNAKE_CASE ) self.assertListEqual( tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['hallo', '!', 'how', 'are', 'you', '?'] ) self.assertListEqual(tokenizer.tokenize('H\u00E9llo' ) , ['hello'] ) def UpperCamelCase ( self : Optional[int] ) -> Any: lowerCamelCase_ = BasicTokenizer(do_lower_case=__SCREAMING_SNAKE_CASE ) self.assertListEqual( tokenizer.tokenize(' \tHeLLo!how \n Are yoU? ' ) , ['HeLLo', '!', 'how', 'Are', 'yoU', '?'] ) def UpperCamelCase ( self : Tuple ) -> Tuple: lowerCamelCase_ = BasicTokenizer(do_lower_case=__SCREAMING_SNAKE_CASE , strip_accents=__SCREAMING_SNAKE_CASE ) self.assertListEqual( tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['HäLLo', '!', 'how', 'Are', 'yoU', '?'] ) def UpperCamelCase ( self : List[str] ) -> List[Any]: lowerCamelCase_ = BasicTokenizer(do_lower_case=__SCREAMING_SNAKE_CASE , strip_accents=__SCREAMING_SNAKE_CASE ) self.assertListEqual( tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['HaLLo', '!', 'how', 'Are', 'yoU', '?'] ) def UpperCamelCase ( self : Tuple ) -> str: lowerCamelCase_ = BasicTokenizer(do_lower_case=__SCREAMING_SNAKE_CASE , never_split=['[UNK]'] ) self.assertListEqual( tokenizer.tokenize(' \tHeLLo!how \n Are yoU? [UNK]' ) , ['HeLLo', '!', 'how', 'Are', 'yoU', '?', '[UNK]'] ) def UpperCamelCase ( self : List[str] ) -> Any: lowerCamelCase_ = ['[UNK]', '[CLS]', '[SEP]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing'] lowerCamelCase_ = {} for i, token in enumerate(__SCREAMING_SNAKE_CASE ): lowerCamelCase_ = i lowerCamelCase_ = WordpieceTokenizer(vocab=__SCREAMING_SNAKE_CASE , unk_token='[UNK]' ) self.assertListEqual(tokenizer.tokenize('' ) , [] ) self.assertListEqual(tokenizer.tokenize('unwanted running' ) , ['un', '##want', '##ed', 'runn', '##ing'] ) self.assertListEqual(tokenizer.tokenize('unwantedX running' ) , ['[UNK]', 'runn', '##ing'] ) def UpperCamelCase ( self : List[Any] ) -> Any: self.assertTrue(_is_whitespace(' ' ) ) self.assertTrue(_is_whitespace('\t' ) ) self.assertTrue(_is_whitespace('\r' ) ) self.assertTrue(_is_whitespace('\n' ) ) self.assertTrue(_is_whitespace('\u00A0' ) ) self.assertFalse(_is_whitespace('A' ) ) self.assertFalse(_is_whitespace('-' ) ) def UpperCamelCase ( self : Union[str, Any] ) -> int: self.assertTrue(_is_control('\u0005' ) ) self.assertFalse(_is_control('A' ) ) self.assertFalse(_is_control(' ' ) ) self.assertFalse(_is_control('\t' ) ) self.assertFalse(_is_control('\r' ) ) def UpperCamelCase ( self : str ) -> Optional[Any]: self.assertTrue(_is_punctuation('-' ) ) self.assertTrue(_is_punctuation('$' ) ) self.assertTrue(_is_punctuation('`' ) ) self.assertTrue(_is_punctuation('.' ) ) self.assertFalse(_is_punctuation('A' ) ) self.assertFalse(_is_punctuation(' ' ) ) def UpperCamelCase ( self : int ) -> List[Any]: lowerCamelCase_ = self.get_tokenizer() lowerCamelCase_ = self.get_rust_tokenizer() # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340 self.assertListEqual([tokenizer.tokenize(__SCREAMING_SNAKE_CASE ) for t in ['Test', '\xad', 'test']] , [['[UNK]'], [], ['[UNK]']] ) self.assertListEqual( [rust_tokenizer.tokenize(__SCREAMING_SNAKE_CASE ) for t in ['Test', '\xad', 'test']] , [['[UNK]'], [], ['[UNK]']] ) @slow def UpperCamelCase ( self : Dict ) -> List[str]: lowerCamelCase_ = self.tokenizer_class.from_pretrained('google/mobilebert-uncased' ) lowerCamelCase_ = tokenizer.encode('sequence builders' , add_special_tokens=__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = tokenizer.encode('multi-sequence build' , add_special_tokens=__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = tokenizer.build_inputs_with_special_tokens(__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = tokenizer.build_inputs_with_special_tokens(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) assert encoded_sentence == [101] + text + [102] assert encoded_pair == [101] + text + [102] + text_a + [102] def UpperCamelCase ( self : Tuple ) -> Union[str, Any]: for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})''' ): lowerCamelCase_ = self.rust_tokenizer_class.from_pretrained(__SCREAMING_SNAKE_CASE , **__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = F'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.''' lowerCamelCase_ = tokenizer_r.encode_plus( __SCREAMING_SNAKE_CASE , return_attention_mask=__SCREAMING_SNAKE_CASE , return_token_type_ids=__SCREAMING_SNAKE_CASE , return_offsets_mapping=__SCREAMING_SNAKE_CASE , add_special_tokens=__SCREAMING_SNAKE_CASE , ) lowerCamelCase_ = tokenizer_r.do_lower_case if hasattr(__SCREAMING_SNAKE_CASE , 'do_lower_case' ) else False lowerCamelCase_ = ( [ ((0, 0), tokenizer_r.cls_token), ((0, 1), 'A'), ((1, 2), ','), ((3, 5), 'na'), ((5, 6), '##ï'), ((6, 8), '##ve'), ((9, 15), tokenizer_r.mask_token), ((16, 21), 'Allen'), ((21, 23), '##NL'), ((23, 24), '##P'), ((25, 33), 'sentence'), ((33, 34), '.'), ((0, 0), tokenizer_r.sep_token), ] if not do_lower_case else [ ((0, 0), tokenizer_r.cls_token), ((0, 1), 'a'), ((1, 2), ','), ((3, 8), 'naive'), ((9, 15), tokenizer_r.mask_token), ((16, 21), 'allen'), ((21, 23), '##nl'), ((23, 24), '##p'), ((25, 33), 'sentence'), ((33, 34), '.'), ((0, 0), tokenizer_r.sep_token), ] ) self.assertEqual( [e[1] for e in expected_results] , tokenizer_r.convert_ids_to_tokens(tokens['input_ids'] ) ) self.assertEqual([e[0] for e in expected_results] , tokens['offset_mapping'] ) def UpperCamelCase ( self : Any ) -> List[Any]: lowerCamelCase_ = ['的', '人', '有'] lowerCamelCase_ = ''.join(__SCREAMING_SNAKE_CASE ) for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})''' ): lowerCamelCase_ = True lowerCamelCase_ = self.tokenizer_class.from_pretrained(__SCREAMING_SNAKE_CASE , **__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = self.rust_tokenizer_class.from_pretrained(__SCREAMING_SNAKE_CASE , **__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = tokenizer_p.encode(__SCREAMING_SNAKE_CASE , add_special_tokens=__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = tokenizer_r.encode(__SCREAMING_SNAKE_CASE , add_special_tokens=__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = tokenizer_r.convert_ids_to_tokens(__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = tokenizer_p.convert_ids_to_tokens(__SCREAMING_SNAKE_CASE ) # it is expected that each Chinese character is not preceded by "##" self.assertListEqual(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) self.assertListEqual(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) lowerCamelCase_ = False lowerCamelCase_ = self.rust_tokenizer_class.from_pretrained(__SCREAMING_SNAKE_CASE , **__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = self.tokenizer_class.from_pretrained(__SCREAMING_SNAKE_CASE , **__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = tokenizer_r.encode(__SCREAMING_SNAKE_CASE , add_special_tokens=__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = tokenizer_p.encode(__SCREAMING_SNAKE_CASE , add_special_tokens=__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = tokenizer_r.convert_ids_to_tokens(__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = tokenizer_p.convert_ids_to_tokens(__SCREAMING_SNAKE_CASE ) # it is expected that only the first Chinese character is not preceded by "##". lowerCamelCase_ = [ F'''##{token}''' if idx != 0 else token for idx, token in enumerate(__SCREAMING_SNAKE_CASE ) ] self.assertListEqual(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) self.assertListEqual(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE )
183
0
import os from shutil import copyfile from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import AddedToken, PreTrainedTokenizer from ...utils import logging _snake_case = logging.get_logger(__name__) _snake_case = "▁" _snake_case = {"vocab_file": "sentencepiece.bpe.model"} _snake_case = { "vocab_file": { "xlm-roberta-base": "https://huggingface.co/xlm-roberta-base/resolve/main/sentencepiece.bpe.model", "xlm-roberta-large": "https://huggingface.co/xlm-roberta-large/resolve/main/sentencepiece.bpe.model", "xlm-roberta-large-finetuned-conll02-dutch": ( "https://huggingface.co/xlm-roberta-large-finetuned-conll02-dutch/resolve/main/sentencepiece.bpe.model" ), "xlm-roberta-large-finetuned-conll02-spanish": ( "https://huggingface.co/xlm-roberta-large-finetuned-conll02-spanish/resolve/main/sentencepiece.bpe.model" ), "xlm-roberta-large-finetuned-conll03-english": ( "https://huggingface.co/xlm-roberta-large-finetuned-conll03-english/resolve/main/sentencepiece.bpe.model" ), "xlm-roberta-large-finetuned-conll03-german": ( "https://huggingface.co/xlm-roberta-large-finetuned-conll03-german/resolve/main/sentencepiece.bpe.model" ), } } _snake_case = { "xlm-roberta-base": 512, "xlm-roberta-large": 512, "xlm-roberta-large-finetuned-conll02-dutch": 512, "xlm-roberta-large-finetuned-conll02-spanish": 512, "xlm-roberta-large-finetuned-conll03-english": 512, "xlm-roberta-large-finetuned-conll03-german": 512, } class lowercase ( UpperCamelCase__ ): _a = VOCAB_FILES_NAMES _a = PRETRAINED_VOCAB_FILES_MAP _a = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _a = ["input_ids", "attention_mask"] def __init__( self , _a , _a="<s>" , _a="</s>" , _a="</s>" , _a="<s>" , _a="<unk>" , _a="<pad>" , _a="<mask>" , _a = None , **_a , ) -> None: # Mask token behave like a normal word, i.e. include the space before it _A : Dict = AddedToken(_a , lstrip=_a , rstrip=_a ) if isinstance(_a , _a ) else mask_token _A : Any = {} if sp_model_kwargs is None else sp_model_kwargs super().__init__( bos_token=_a , eos_token=_a , unk_token=_a , sep_token=_a , cls_token=_a , pad_token=_a , mask_token=_a , sp_model_kwargs=self.sp_model_kwargs , **_a , ) _A : str = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(str(_a ) ) _A : Optional[Any] = vocab_file # Original fairseq vocab and spm vocab must be "aligned": # Vocab | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 # -------- | ------- | ------- | ------ | ------- | --- | --- | --- | ----- | ----- | ---- # fairseq | '<s>' | '<pad>' | '</s>' | '<unk>' | ',' | '.' | '▁' | 's' | '▁de' | '-' # spm | '<unk>' | '<s>' | '</s>' | ',' | '.' | '▁' | 's' | '▁de' | '-' | '▁a' # Mimic fairseq token-to-id alignment for the first 4 token _A : Tuple = {"""<s>""": 0, """<pad>""": 1, """</s>""": 2, """<unk>""": 3} # The first "real" token "," has position 4 in the original fairseq vocab and position 3 in the spm vocab _A : Any = 1 _A : List[Any] = len(self.sp_model ) + self.fairseq_offset _A : Tuple = {v: k for k, v in self.fairseq_tokens_to_ids.items()} def __getstate__( self ) -> Any: _A : str = self.__dict__.copy() _A : int = None _A : Optional[int] = self.sp_model.serialized_model_proto() return state def __setstate__( self , _a ) -> int: _A : int = d # for backward compatibility if not hasattr(self , """sp_model_kwargs""" ): _A : List[str] = {} _A : Optional[int] = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.LoadFromSerializedProto(self.sp_model_proto ) def a__ ( self , _a , _a = None ) -> List[int]: if token_ids_a is None: return [self.cls_token_id] + token_ids_a + [self.sep_token_id] _A : Optional[Any] = [self.cls_token_id] _A : List[Any] = [self.sep_token_id] return cls + token_ids_a + sep + sep + token_ids_a + sep def a__ ( self , _a , _a = None , _a = False ) -> List[int]: 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 a__ ( self , _a , _a = None ) -> List[int]: _A : Optional[Any] = [self.sep_token_id] _A : Any = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0] @property def a__ ( self ) -> Dict: return len(self.sp_model ) + self.fairseq_offset + 1 # Add the <mask> token def a__ ( self ) -> str: _A : Dict = {self.convert_ids_to_tokens(_a ): i for i in range(self.vocab_size )} vocab.update(self.added_tokens_encoder ) return vocab def a__ ( self , _a ) -> List[str]: return self.sp_model.encode(_a , out_type=_a ) def a__ ( self , _a ) -> Any: if token in self.fairseq_tokens_to_ids: return self.fairseq_tokens_to_ids[token] _A : int = self.sp_model.PieceToId(_a ) # Need to return unknown token if the SP model returned 0 return spm_id + self.fairseq_offset if spm_id else self.unk_token_id def a__ ( self , _a ) -> str: if index in self.fairseq_ids_to_tokens: return self.fairseq_ids_to_tokens[index] return self.sp_model.IdToPiece(index - self.fairseq_offset ) def a__ ( self , _a ) -> Dict: _A : int = """""".join(_a ).replace(_a , """ """ ).strip() return out_string def a__ ( self , _a , _a = None ) -> Tuple[str]: if not os.path.isdir(_a ): logger.error(F'''Vocabulary path ({save_directory}) should be a directory''' ) return _A : str = os.path.join( _a , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(_a ) and os.path.isfile(self.vocab_file ): copyfile(self.vocab_file , _a ) elif not os.path.isfile(self.vocab_file ): with open(_a , """wb""" ) as fi: _A : Tuple = self.sp_model.serialized_model_proto() fi.write(_a ) return (out_vocab_file,)
368
from __future__ import annotations from decimal import Decimal from numpy import array def lowerCAmelCase_ ( snake_case_ ): _A : Tuple = Decimal # Check if the provided matrix has 2 rows and 2 columns # since this implementation only works for 2x2 matrices if len(snake_case_ ) == 2 and len(matrix[0] ) == 2 and len(matrix[1] ) == 2: # Calculate the determinant of the matrix _A : List[Any] = float( d(matrix[0][0] ) * d(matrix[1][1] ) - d(matrix[1][0] ) * d(matrix[0][1] ) ) if determinant == 0: raise ValueError("""This matrix has no inverse.""" ) # Creates a copy of the matrix with swapped positions of the elements _A : Tuple = [[0.0, 0.0], [0.0, 0.0]] _A , _A : List[str] = matrix[1][1], matrix[0][0] _A , _A : List[str] = -matrix[1][0], -matrix[0][1] # Calculate the inverse of the matrix return [ [(float(d(snake_case_ ) ) / determinant) or 0.0 for n in row] for row in swapped_matrix ] elif ( len(snake_case_ ) == 3 and len(matrix[0] ) == 3 and len(matrix[1] ) == 3 and len(matrix[2] ) == 3 ): # Calculate the determinant of the matrix using Sarrus rule _A : List[str] = float( ( (d(matrix[0][0] ) * d(matrix[1][1] ) * d(matrix[2][2] )) + (d(matrix[0][1] ) * d(matrix[1][2] ) * d(matrix[2][0] )) + (d(matrix[0][2] ) * d(matrix[1][0] ) * d(matrix[2][1] )) ) - ( (d(matrix[0][2] ) * d(matrix[1][1] ) * d(matrix[2][0] )) + (d(matrix[0][1] ) * d(matrix[1][0] ) * d(matrix[2][2] )) + (d(matrix[0][0] ) * d(matrix[1][2] ) * d(matrix[2][1] )) ) ) if determinant == 0: raise ValueError("""This matrix has no inverse.""" ) # Creating cofactor matrix _A : List[Any] = [ [d(0.0 ), d(0.0 ), d(0.0 )], [d(0.0 ), d(0.0 ), d(0.0 )], [d(0.0 ), d(0.0 ), d(0.0 )], ] _A : Union[str, Any] = (d(matrix[1][1] ) * d(matrix[2][2] )) - ( d(matrix[1][2] ) * d(matrix[2][1] ) ) _A : Optional[Any] = -( (d(matrix[1][0] ) * d(matrix[2][2] )) - (d(matrix[1][2] ) * d(matrix[2][0] )) ) _A : Any = (d(matrix[1][0] ) * d(matrix[2][1] )) - ( d(matrix[1][1] ) * d(matrix[2][0] ) ) _A : List[Any] = -( (d(matrix[0][1] ) * d(matrix[2][2] )) - (d(matrix[0][2] ) * d(matrix[2][1] )) ) _A : int = (d(matrix[0][0] ) * d(matrix[2][2] )) - ( d(matrix[0][2] ) * d(matrix[2][0] ) ) _A : Union[str, Any] = -( (d(matrix[0][0] ) * d(matrix[2][1] )) - (d(matrix[0][1] ) * d(matrix[2][0] )) ) _A : Any = (d(matrix[0][1] ) * d(matrix[1][2] )) - ( d(matrix[0][2] ) * d(matrix[1][1] ) ) _A : List[str] = -( (d(matrix[0][0] ) * d(matrix[1][2] )) - (d(matrix[0][2] ) * d(matrix[1][0] )) ) _A : Optional[int] = (d(matrix[0][0] ) * d(matrix[1][1] )) - ( d(matrix[0][1] ) * d(matrix[1][0] ) ) # Transpose the cofactor matrix (Adjoint matrix) _A : List[Any] = array(snake_case_ ) for i in range(3 ): for j in range(3 ): _A : List[str] = cofactor_matrix[j][i] # Inverse of the matrix using the formula (1/determinant) * adjoint matrix _A : Union[str, Any] = array(snake_case_ ) for i in range(3 ): for j in range(3 ): inverse_matrix[i][j] /= d(snake_case_ ) # Calculate the inverse of the matrix return [[float(d(snake_case_ ) ) or 0.0 for n in row] for row in inverse_matrix] raise ValueError("""Please provide a matrix of size 2x2 or 3x3.""" )
343
0
import unittest from transformers import EsmConfig, is_torch_available from transformers.testing_utils import TestCasePlus, require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers.models.esm.modeling_esmfold import EsmForProteinFolding class __snake_case : def __init__( self : List[str] , A_ : str , A_ : List[Any]=1_3 , A_ : List[str]=7 , A_ : List[Any]=False , A_ : int=True , A_ : int=False , A_ : str=False , A_ : Optional[Any]=1_9 , A_ : Optional[int]=3_2 , A_ : Any=5 , A_ : Union[str, Any]=4 , A_ : Dict=3_7 , A_ : Optional[int]="gelu" , A_ : Tuple=0.1 , A_ : List[Any]=0.1 , A_ : Optional[int]=5_1_2 , A_ : Optional[Any]=1_6 , A_ : List[Any]=2 , A_ : List[Any]=0.02 , A_ : List[Any]=3 , A_ : str=4 , A_ : Tuple=None , ): lowerCAmelCase_ : List[Any] = parent lowerCAmelCase_ : int = batch_size lowerCAmelCase_ : Optional[Any] = seq_length lowerCAmelCase_ : Dict = is_training lowerCAmelCase_ : List[str] = use_input_mask lowerCAmelCase_ : Union[str, Any] = use_token_type_ids lowerCAmelCase_ : Optional[Any] = use_labels lowerCAmelCase_ : int = vocab_size lowerCAmelCase_ : List[Any] = hidden_size lowerCAmelCase_ : str = num_hidden_layers lowerCAmelCase_ : List[Any] = num_attention_heads lowerCAmelCase_ : int = intermediate_size lowerCAmelCase_ : Optional[Any] = hidden_act lowerCAmelCase_ : str = hidden_dropout_prob lowerCAmelCase_ : List[str] = attention_probs_dropout_prob lowerCAmelCase_ : Optional[int] = max_position_embeddings lowerCAmelCase_ : Optional[Any] = type_vocab_size lowerCAmelCase_ : Dict = type_sequence_label_size lowerCAmelCase_ : Union[str, Any] = initializer_range lowerCAmelCase_ : Dict = num_labels lowerCAmelCase_ : Union[str, Any] = num_choices lowerCAmelCase_ : str = scope def UpperCAmelCase__ ( self : Any): lowerCAmelCase_ : Dict = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size) lowerCAmelCase_ : Union[str, Any] = None if self.use_input_mask: lowerCAmelCase_ : List[str] = random_attention_mask([self.batch_size, self.seq_length]) lowerCAmelCase_ : List[str] = None lowerCAmelCase_ : Any = None lowerCAmelCase_ : str = None if self.use_labels: lowerCAmelCase_ : List[str] = ids_tensor([self.batch_size] , self.type_sequence_label_size) lowerCAmelCase_ : int = ids_tensor([self.batch_size, self.seq_length] , self.num_labels) lowerCAmelCase_ : Dict = ids_tensor([self.batch_size] , self.num_choices) lowerCAmelCase_ : Any = self.get_config() return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels def UpperCAmelCase__ ( self : Tuple): lowerCAmelCase_ : List[str] = EsmConfig( vocab_size=3_3 , hidden_size=self.hidden_size , pad_token_id=1 , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , initializer_range=self.initializer_range , is_folding_model=A_ , esmfold_config={'''trunk''': {'''num_blocks''': 2}, '''fp16_esm''': False} , ) return config def UpperCAmelCase__ ( self : Optional[int] , A_ : List[Any] , A_ : Dict , A_ : List[Any] , A_ : str , A_ : str , A_ : Dict): lowerCAmelCase_ : List[Any] = EsmForProteinFolding(config=A_).float() model.to(A_) model.eval() lowerCAmelCase_ : Optional[Any] = model(A_ , attention_mask=A_) lowerCAmelCase_ : Union[str, Any] = model(A_) lowerCAmelCase_ : List[Any] = model(A_) self.parent.assertEqual(result.positions.shape , (8, self.batch_size, self.seq_length, 1_4, 3)) self.parent.assertEqual(result.angles.shape , (8, self.batch_size, self.seq_length, 7, 2)) def UpperCAmelCase__ ( self : Tuple): lowerCAmelCase_ : Union[str, Any] = self.prepare_config_and_inputs() ( ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ) : Union[str, Any] = config_and_inputs lowerCAmelCase_ : List[Any] = {'''input_ids''': input_ids, '''attention_mask''': input_mask} return config, inputs_dict @require_torch class __snake_case ( UpperCamelCase_ ,UpperCamelCase_ ,unittest.TestCase ): _a = False _a = (EsmForProteinFolding,) if is_torch_available() else () _a = () _a = {} if is_torch_available() else {} _a = False def UpperCAmelCase__ ( self : str): lowerCAmelCase_ : Optional[Any] = EsmFoldModelTester(self) lowerCAmelCase_ : Union[str, Any] = ConfigTester(self , config_class=A_ , hidden_size=3_7) def UpperCAmelCase__ ( self : Dict): self.config_tester.run_common_tests() def UpperCAmelCase__ ( self : int): lowerCAmelCase_ : Dict = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*A_) @unittest.skip('''Does not support attention outputs''') def UpperCAmelCase__ ( self : Any): pass @unittest.skip def UpperCAmelCase__ ( self : Tuple): pass @unittest.skip('''Esm does not support embedding resizing''') def UpperCAmelCase__ ( self : Any): pass @unittest.skip('''Esm does not support embedding resizing''') def UpperCAmelCase__ ( self : List[Any]): pass @unittest.skip('''ESMFold does not support passing input embeds!''') def UpperCAmelCase__ ( self : Optional[Any]): pass @unittest.skip('''ESMFold does not support head pruning.''') def UpperCAmelCase__ ( self : Tuple): pass @unittest.skip('''ESMFold does not support head pruning.''') def UpperCAmelCase__ ( self : Dict): pass @unittest.skip('''ESMFold does not support head pruning.''') def UpperCAmelCase__ ( self : Optional[int]): pass @unittest.skip('''ESMFold does not support head pruning.''') def UpperCAmelCase__ ( self : str): pass @unittest.skip('''ESMFold does not support head pruning.''') def UpperCAmelCase__ ( self : List[str]): pass @unittest.skip('''ESMFold does not output hidden states in the normal way.''') def UpperCAmelCase__ ( self : Optional[Any]): pass @unittest.skip('''ESMfold does not output hidden states in the normal way.''') def UpperCAmelCase__ ( self : List[Any]): pass @unittest.skip('''ESMFold only has one output format.''') def UpperCAmelCase__ ( self : Optional[int]): pass @unittest.skip('''This test doesn\'t work for ESMFold and doesn\'t test core functionality''') def UpperCAmelCase__ ( self : Tuple): pass @unittest.skip('''ESMFold does not support input chunking.''') def UpperCAmelCase__ ( self : str): pass @unittest.skip('''ESMFold doesn\'t respect you and it certainly doesn\'t respect your initialization arguments.''') def UpperCAmelCase__ ( self : str): pass @unittest.skip('''ESMFold doesn\'t support torchscript compilation.''') def UpperCAmelCase__ ( self : Dict): pass @unittest.skip('''ESMFold doesn\'t support torchscript compilation.''') def UpperCAmelCase__ ( self : List[str]): pass @unittest.skip('''ESMFold doesn\'t support torchscript compilation.''') def UpperCAmelCase__ ( self : List[Any]): pass @unittest.skip('''ESMFold doesn\'t support data parallel.''') def UpperCAmelCase__ ( self : List[str]): pass @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.''') def UpperCAmelCase__ ( self : Any): pass @require_torch class __snake_case ( UpperCamelCase_ ): @slow def UpperCAmelCase__ ( self : int): lowerCAmelCase_ : Optional[int] = EsmForProteinFolding.from_pretrained('''facebook/esmfold_v1''').float() model.eval() lowerCAmelCase_ : Optional[Any] = torch.tensor([[0, 6, 4, 1_3, 5, 4, 1_6, 1_2, 1_1, 7, 2]]) lowerCAmelCase_ : Dict = model(A_)['''positions'''] lowerCAmelCase_ : Any = torch.tensor([2.5828, 0.7993, -10.9334] , dtype=torch.floataa) self.assertTrue(torch.allclose(position_outputs[0, 0, 0, 0] , A_ , atol=1e-4))
103
import darl # noqa import gym import tqdm from diffusers.experimental import ValueGuidedRLPipeline A__ : Union[str, Any] = { '''n_samples''': 64, '''horizon''': 32, '''num_inference_steps''': 20, '''n_guide_steps''': 2, # can set to 0 for faster sampling, does not use value network '''scale_grad_by_std''': True, '''scale''': 0.1, '''eta''': 0.0, '''t_grad_cutoff''': 2, '''device''': '''cpu''', } if __name__ == "__main__": A__ : Optional[int] = '''hopper-medium-v2''' A__ : int = gym.make(env_name) A__ : Optional[int] = ValueGuidedRLPipeline.from_pretrained( '''bglick13/hopper-medium-v2-value-function-hor32''', env=env, ) env.seed(0) A__ : int = env.reset() A__ : Optional[int] = 0 A__ : Union[str, Any] = 0 A__ : Union[str, Any] = 1000 A__ : Optional[Any] = [obs.copy()] try: for t in tqdm.tqdm(range(T)): # call the policy A__ : Union[str, Any] = pipeline(obs, planning_horizon=32) # execute action in environment A__ , A__ , A__ , A__ : str = env.step(denorm_actions) A__ : Dict = env.get_normalized_score(total_reward) # update return total_reward += reward total_score += score print( F'''Step: {t}, Reward: {reward}, Total Reward: {total_reward}, Score: {score}, Total Score:''' F''' {total_score}''' ) # save observations for rendering rollout.append(next_observation.copy()) A__ : List[str] = next_observation except KeyboardInterrupt: pass print(F'''Total reward: {total_reward}''')
103
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available, is_vision_available, ) __A ={ '''configuration_perceiver''': ['''PERCEIVER_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''PerceiverConfig''', '''PerceiverOnnxConfig'''], '''tokenization_perceiver''': ['''PerceiverTokenizer'''], } try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =['''PerceiverFeatureExtractor'''] __A =['''PerceiverImageProcessor'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''PERCEIVER_PRETRAINED_MODEL_ARCHIVE_LIST''', '''PerceiverForImageClassificationConvProcessing''', '''PerceiverForImageClassificationFourier''', '''PerceiverForImageClassificationLearned''', '''PerceiverForMaskedLM''', '''PerceiverForMultimodalAutoencoding''', '''PerceiverForOpticalFlow''', '''PerceiverForSequenceClassification''', '''PerceiverLayer''', '''PerceiverModel''', '''PerceiverPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_perceiver import PERCEIVER_PRETRAINED_CONFIG_ARCHIVE_MAP, PerceiverConfig, PerceiverOnnxConfig from .tokenization_perceiver import PerceiverTokenizer try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_perceiver import PerceiverFeatureExtractor from .image_processing_perceiver import PerceiverImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_perceiver import ( PERCEIVER_PRETRAINED_MODEL_ARCHIVE_LIST, PerceiverForImageClassificationConvProcessing, PerceiverForImageClassificationFourier, PerceiverForImageClassificationLearned, PerceiverForMaskedLM, PerceiverForMultimodalAutoencoding, PerceiverForOpticalFlow, PerceiverForSequenceClassification, PerceiverLayer, PerceiverModel, PerceiverPreTrainedModel, ) else: import sys __A =_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
364
from collections import defaultdict def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ ): lowerCamelCase_ = first_str.lower().strip() lowerCamelCase_ = second_str.lower().strip() # Remove whitespace lowerCamelCase_ = first_str.replace(" " , "" ) lowerCamelCase_ = second_str.replace(" " , "" ) # Strings of different lengths are not anagrams if len(lowerCamelCase__ ) != len(lowerCamelCase__ ): return False # Default values for count should be 0 lowerCamelCase_ = defaultdict(lowerCamelCase__ ) # For each character in input strings, # increment count in the corresponding for i in range(len(lowerCamelCase__ ) ): count[first_str[i]] += 1 count[second_str[i]] -= 1 return all(_count == 0 for _count in count.values() ) if __name__ == "__main__": from doctest import testmod testmod() __A =input('''Enter the first string ''').strip() __A =input('''Enter the second string ''').strip() __A =check_anagrams(input_a, input_b) print(F"""{input_a} and {input_b} are {"" if status else "not "}anagrams.""")
47
0
'''simple docstring''' from typing import Any def a__ ( lowercase : Dict, lowercase : List[Any], lowercase : int, lowercase : Tuple, lowercase : Dict, ) -> list: """simple docstring""" _validation( snake_case__, snake_case__, snake_case__, snake_case__, snake_case__, ) # Creates data structures and fill initial step _UpperCamelCase = {} _UpperCamelCase = {} for state in states_space: _UpperCamelCase = observations_space[0] _UpperCamelCase = ( initial_probabilities[state] * emission_probabilities[state][observation] ) _UpperCamelCase = None # Fills the data structure with the probabilities of # different transitions and pointers to previous states for o in range(1, len(snake_case__ ) ): _UpperCamelCase = observations_space[o] _UpperCamelCase = observations_space[o - 1] for state in states_space: # Calculates the argmax for probability function _UpperCamelCase = '''''' _UpperCamelCase = -1 for k_state in states_space: _UpperCamelCase = ( probabilities[(k_state, prior_observation)] * transition_probabilities[k_state][state] * emission_probabilities[state][observation] ) if probability > max_probability: _UpperCamelCase = probability _UpperCamelCase = k_state # Update probabilities and pointers dicts _UpperCamelCase = ( probabilities[(arg_max, prior_observation)] * transition_probabilities[arg_max][state] * emission_probabilities[state][observation] ) _UpperCamelCase = arg_max # The final observation _UpperCamelCase = observations_space[len(snake_case__ ) - 1] # argmax for given final observation _UpperCamelCase = '''''' _UpperCamelCase = -1 for k_state in states_space: _UpperCamelCase = probabilities[(k_state, final_observation)] if probability > max_probability: _UpperCamelCase = probability _UpperCamelCase = k_state _UpperCamelCase = arg_max # Process pointers backwards _UpperCamelCase = last_state _UpperCamelCase = [] for o in range(len(snake_case__ ) - 1, -1, -1 ): result.append(snake_case__ ) _UpperCamelCase = pointers[previous, observations_space[o]] result.reverse() return result def a__ ( lowercase : str, lowercase : Union[str, Any], lowercase : List[str], lowercase : Tuple, lowercase : Tuple, ) -> None: """simple docstring""" _validate_not_empty( snake_case__, snake_case__, snake_case__, snake_case__, snake_case__, ) _validate_lists(snake_case__, snake_case__ ) _validate_dicts( snake_case__, snake_case__, snake_case__ ) def a__ ( lowercase : Optional[int], lowercase : Optional[int], lowercase : List[Any], lowercase : Optional[Any], lowercase : int, ) -> None: """simple docstring""" if not all( [ observations_space, states_space, initial_probabilities, transition_probabilities, emission_probabilities, ] ): raise ValueError('''There\'s an empty parameter''' ) def a__ ( lowercase : Optional[Any], lowercase : List[Any] ) -> None: """simple docstring""" _validate_list(snake_case__, '''observations_space''' ) _validate_list(snake_case__, '''states_space''' ) def a__ ( lowercase : str, lowercase : Tuple ) -> None: """simple docstring""" if not isinstance(_object, snake_case__ ): _UpperCamelCase = F"""{var_name} must be a list""" raise ValueError(snake_case__ ) else: for x in _object: if not isinstance(snake_case__, snake_case__ ): _UpperCamelCase = F"""{var_name} must be a list of strings""" raise ValueError(snake_case__ ) def a__ ( lowercase : List[str], lowercase : Any, lowercase : Union[str, Any], ) -> None: """simple docstring""" _validate_dict(snake_case__, '''initial_probabilities''', snake_case__ ) _validate_nested_dict(snake_case__, '''transition_probabilities''' ) _validate_nested_dict(snake_case__, '''emission_probabilities''' ) def a__ ( lowercase : Optional[Any], lowercase : Tuple ) -> None: """simple docstring""" _validate_dict(_object, snake_case__, snake_case__ ) for x in _object.values(): _validate_dict(snake_case__, snake_case__, snake_case__, snake_case__ ) def a__ ( lowercase : List[Any], lowercase : List[str], lowercase : Union[str, Any], lowercase : Union[str, Any] = False ) -> None: """simple docstring""" if not isinstance(_object, snake_case__ ): _UpperCamelCase = F"""{var_name} must be a dict""" raise ValueError(snake_case__ ) if not all(isinstance(snake_case__, snake_case__ ) for x in _object ): _UpperCamelCase = F"""{var_name} all keys must be strings""" raise ValueError(snake_case__ ) if not all(isinstance(snake_case__, snake_case__ ) for x in _object.values() ): _UpperCamelCase = '''nested dictionary ''' if nested else '''''' _UpperCamelCase = F"""{var_name} {nested_text}all values must be {value_type.__name__}""" raise ValueError(snake_case__ ) if __name__ == "__main__": from doctest import testmod testmod()
324
"""simple docstring""" import unittest from transformers import ( MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING, TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING, TextaTextGenerationPipeline, pipeline, ) from transformers.testing_utils import is_pipeline_test, require_tf, require_torch from transformers.utils import is_torch_available from .test_pipelines_common import ANY if is_torch_available(): import torch @is_pipeline_test class __magic_name__ ( unittest.TestCase ): '''simple docstring''' __UpperCamelCase = MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING __UpperCamelCase = TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING def _lowerCAmelCase ( self , _a , _a , _a ): """simple docstring""" lowerCamelCase = TextaTextGenerationPipeline(model=_a , tokenizer=_a ) return generator, ["Something to write", "Something else"] def _lowerCAmelCase ( self , _a , _a ): """simple docstring""" lowerCamelCase = generator("""Something there""" ) self.assertEqual(_a , [{"""generated_text""": ANY(_a )}] ) # These are encoder decoder, they don't just append to incoming string self.assertFalse(outputs[0]["""generated_text"""].startswith("""Something there""" ) ) lowerCamelCase = generator(["""This is great !""", """Something else"""] , num_return_sequences=2 , do_sample=_a ) self.assertEqual( _a , [ [{"""generated_text""": ANY(_a )}, {"""generated_text""": ANY(_a )}], [{"""generated_text""": ANY(_a )}, {"""generated_text""": ANY(_a )}], ] , ) lowerCamelCase = generator( ["""This is great !""", """Something else"""] , num_return_sequences=2 , batch_size=2 , do_sample=_a ) self.assertEqual( _a , [ [{"""generated_text""": ANY(_a )}, {"""generated_text""": ANY(_a )}], [{"""generated_text""": ANY(_a )}, {"""generated_text""": ANY(_a )}], ] , ) with self.assertRaises(_a ): generator(4 ) @require_torch def _lowerCAmelCase ( self ): """simple docstring""" lowerCamelCase = pipeline("""text2text-generation""" , model="""patrickvonplaten/t5-tiny-random""" , framework="""pt""" ) # do_sample=False necessary for reproducibility lowerCamelCase = generator("""Something there""" , do_sample=_a ) self.assertEqual(_a , [{"""generated_text""": """"""}] ) lowerCamelCase = 3 lowerCamelCase = generator( """Something there""" , num_return_sequences=_a , num_beams=_a , ) lowerCamelCase = [ {"""generated_text""": """Beide Beide Beide Beide Beide Beide Beide Beide Beide"""}, {"""generated_text""": """Beide Beide Beide Beide Beide Beide Beide Beide"""}, {"""generated_text""": """"""}, ] self.assertEqual(_a , _a ) lowerCamelCase = generator("""This is a test""" , do_sample=_a , num_return_sequences=2 , return_tensors=_a ) self.assertEqual( _a , [ {"""generated_token_ids""": ANY(torch.Tensor )}, {"""generated_token_ids""": ANY(torch.Tensor )}, ] , ) lowerCamelCase = generator.model.config.eos_token_id lowerCamelCase = """<pad>""" lowerCamelCase = generator( ["""This is a test""", """This is a second test"""] , do_sample=_a , num_return_sequences=2 , batch_size=2 , return_tensors=_a , ) self.assertEqual( _a , [ [ {"""generated_token_ids""": ANY(torch.Tensor )}, {"""generated_token_ids""": ANY(torch.Tensor )}, ], [ {"""generated_token_ids""": ANY(torch.Tensor )}, {"""generated_token_ids""": ANY(torch.Tensor )}, ], ] , ) @require_tf def _lowerCAmelCase ( self ): """simple docstring""" lowerCamelCase = pipeline("""text2text-generation""" , model="""patrickvonplaten/t5-tiny-random""" , framework="""tf""" ) # do_sample=False necessary for reproducibility lowerCamelCase = generator("""Something there""" , do_sample=_a ) self.assertEqual(_a , [{"""generated_text""": """"""}] )
291
0
'''simple docstring''' import warnings from ..trainer import Trainer from ..utils import logging UpperCamelCase = logging.get_logger(__name__) class lowerCAmelCase_ ( UpperCAmelCase_ ): '''simple docstring''' def __init__( self : Union[str, Any] , SCREAMING_SNAKE_CASE_ : Optional[int]=None , **SCREAMING_SNAKE_CASE_ : Any ) -> Tuple: '''simple docstring''' warnings.warn( '''`SageMakerTrainer` is deprecated and will be removed in v5 of Transformers. You can use `Trainer` ''' '''instead.''' , SCREAMING_SNAKE_CASE_ , ) super().__init__(args=SCREAMING_SNAKE_CASE_ , **SCREAMING_SNAKE_CASE_ )
358
'''simple docstring''' from __future__ import annotations from typing import Any class lowerCAmelCase_ ( UpperCAmelCase_ ): '''simple docstring''' pass class lowerCAmelCase_ : '''simple docstring''' def __init__( self : List[Any] , SCREAMING_SNAKE_CASE_ : Any ) -> None: '''simple docstring''' A: Any = data A: Node | None = None def __iter__( self : Optional[int] ) -> List[str]: '''simple docstring''' A: List[str] = self A: Dict = [] while node: if node in visited: raise ContainsLoopError visited.append(SCREAMING_SNAKE_CASE_ ) yield node.data A: str = node.next_node @property def _snake_case ( self : List[str] ) -> bool: '''simple docstring''' try: list(self ) return False except ContainsLoopError: return True if __name__ == "__main__": UpperCamelCase = Node(1) UpperCamelCase = Node(2) UpperCamelCase = Node(3) UpperCamelCase = Node(4) print(root_node.has_loop) # False UpperCamelCase = root_node.next_node print(root_node.has_loop) # True UpperCamelCase = Node(5) UpperCamelCase = Node(6) UpperCamelCase = Node(5) UpperCamelCase = Node(6) print(root_node.has_loop) # False UpperCamelCase = Node(1) print(root_node.has_loop) # False
334
0
import argparse import os from io import BytesIO from pathlib import Path import requests from clip_retrieval.clip_client import ClipClient from PIL import Image from tqdm import tqdm def lowerCamelCase_ ( UpperCamelCase__ : Any , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : str ) -> List[str]: """simple docstring""" __lowerCamelCase = 1.5 __lowerCamelCase = int(factor * num_class_images ) __lowerCamelCase = ClipClient( url='https://knn.laion.ai/knn-service' , indice_name='laion_400m' , num_images=UpperCamelCase__ , aesthetic_weight=0.1 ) os.makedirs(F"""{class_data_dir}/images""" , exist_ok=UpperCamelCase__ ) if len(list(Path(F"""{class_data_dir}/images""" ).iterdir() ) ) >= num_class_images: return while True: __lowerCamelCase = client.query(text=UpperCamelCase__ ) if len(UpperCamelCase__ ) >= factor * num_class_images or num_images > 1E4: break else: __lowerCamelCase = int(factor * num_images ) __lowerCamelCase = ClipClient( url='https://knn.laion.ai/knn-service' , indice_name='laion_400m' , num_images=UpperCamelCase__ , aesthetic_weight=0.1 , ) __lowerCamelCase = 0 __lowerCamelCase = 0 __lowerCamelCase = tqdm(desc='downloading real regularization images' , total=UpperCamelCase__ ) with open(F"""{class_data_dir}/caption.txt""" , 'w' ) as fa, open(F"""{class_data_dir}/urls.txt""" , 'w' ) as fa, open( F"""{class_data_dir}/images.txt""" , 'w' ) as fa: while total < num_class_images: __lowerCamelCase = class_images[count] count += 1 try: __lowerCamelCase = requests.get(images['url'] ) if img.status_code == 200: __lowerCamelCase = Image.open(BytesIO(img.content ) ) with open(F"""{class_data_dir}/images/{total}.jpg""" , 'wb' ) as f: f.write(img.content ) fa.write(images['caption'] + '\n' ) fa.write(images['url'] + '\n' ) fa.write(F"""{class_data_dir}/images/{total}.jpg""" + '\n' ) total += 1 pbar.update(1 ) else: continue except Exception: continue return def lowerCamelCase_ ( ) -> Any: """simple docstring""" __lowerCamelCase = argparse.ArgumentParser('' , add_help=UpperCamelCase__ ) parser.add_argument('--class_prompt' , help='text prompt to retrieve images' , required=UpperCamelCase__ , type=UpperCamelCase__ ) parser.add_argument('--class_data_dir' , help='path to save images' , required=UpperCamelCase__ , type=UpperCamelCase__ ) parser.add_argument('--num_class_images' , help='number of images to download' , default=200 , type=UpperCamelCase__ ) return parser.parse_args() if __name__ == "__main__": __A = parse_args() retrieve(args.class_prompt, args.class_data_dir, args.num_class_images)
90
import numpy as np import torch from torch.utils.data import Dataset, IterableDataset from ..utils.generic import ModelOutput class UpperCAmelCase_ ( UpperCamelCase_ ): '''simple docstring''' def __init__( self , _A , _A , _A ): '''simple docstring''' __SCREAMING_SNAKE_CASE = dataset __SCREAMING_SNAKE_CASE = process __SCREAMING_SNAKE_CASE = params def __len__( self ): '''simple docstring''' return len(self.dataset ) def __getitem__( self , _A ): '''simple docstring''' __SCREAMING_SNAKE_CASE = self.dataset[i] __SCREAMING_SNAKE_CASE = self.process(_A , **self.params ) return processed class UpperCAmelCase_ ( UpperCamelCase_ ): '''simple docstring''' def __init__( self , _A , _A , _A , _A=None ): '''simple docstring''' __SCREAMING_SNAKE_CASE = loader __SCREAMING_SNAKE_CASE = infer __SCREAMING_SNAKE_CASE = params if loader_batch_size == 1: # Let's spare some time by deactivating altogether __SCREAMING_SNAKE_CASE = None __SCREAMING_SNAKE_CASE = loader_batch_size # Internal bookkeeping __SCREAMING_SNAKE_CASE = None __SCREAMING_SNAKE_CASE = None def __len__( self ): '''simple docstring''' return len(self.loader ) def __iter__( self ): '''simple docstring''' __SCREAMING_SNAKE_CASE = iter(self.loader ) return self def _A ( self ): '''simple docstring''' if isinstance(self._loader_batch_data , torch.Tensor ): # Batch data is simple tensor, just fetch the slice __SCREAMING_SNAKE_CASE = self._loader_batch_data[self._loader_batch_index] else: # Batch data is assumed to be BaseModelOutput (or dict) __SCREAMING_SNAKE_CASE = {} for k, element in self._loader_batch_data.items(): if isinstance(_A , _A ): # Convert ModelOutput to tuple first __SCREAMING_SNAKE_CASE = element.to_tuple() if isinstance(element[0] , torch.Tensor ): __SCREAMING_SNAKE_CASE = tuple(el[self._loader_batch_index].unsqueeze(0 ) for el in element ) elif isinstance(element[0] , np.ndarray ): __SCREAMING_SNAKE_CASE = tuple(np.expand_dims(el[self._loader_batch_index] , 0 ) for el in element ) continue if k in {"hidden_states", "past_key_values", "attentions"} and isinstance(_A , _A ): # Those are stored as lists of tensors so need specific unbatching. if isinstance(element[0] , torch.Tensor ): __SCREAMING_SNAKE_CASE = tuple(el[self._loader_batch_index].unsqueeze(0 ) for el in element ) elif isinstance(element[0] , np.ndarray ): __SCREAMING_SNAKE_CASE = tuple(np.expand_dims(el[self._loader_batch_index] , 0 ) for el in element ) continue if element is None: # This can happen for optional data that get passed around __SCREAMING_SNAKE_CASE = None elif isinstance(element[self._loader_batch_index] , torch.Tensor ): # Take correct batch data, but make it looked like batch_size=1 # For compatibility with other methods within transformers __SCREAMING_SNAKE_CASE = element[self._loader_batch_index].unsqueeze(0 ) elif isinstance(element[self._loader_batch_index] , np.ndarray ): # Take correct batch data, but make it looked like batch_size=1 # For compatibility with other methods within transformers __SCREAMING_SNAKE_CASE = np.expand_dims(element[self._loader_batch_index] , 0 ) else: # This is typically a list, so no need to `unsqueeze`. __SCREAMING_SNAKE_CASE = element[self._loader_batch_index] # Recreate the element by reusing the original class to make it look # batch_size=1 __SCREAMING_SNAKE_CASE = self._loader_batch_data.__class__(_A ) self._loader_batch_index += 1 return result def _A ( self ): '''simple docstring''' if self._loader_batch_index is not None and self._loader_batch_index < self.loader_batch_size: # We are currently unrolling a batch so we just need to return # the current item within a batch return self.loader_batch_item() # We're out of items within a batch __SCREAMING_SNAKE_CASE = next(self.iterator ) __SCREAMING_SNAKE_CASE = self.infer(_A , **self.params ) # We now have a batch of "inferred things". if self.loader_batch_size is not None: # Try to infer the size of the batch if isinstance(_A , torch.Tensor ): __SCREAMING_SNAKE_CASE = processed else: __SCREAMING_SNAKE_CASE = list(processed.keys() )[0] __SCREAMING_SNAKE_CASE = processed[key] if isinstance(_A , _A ): __SCREAMING_SNAKE_CASE = len(_A ) else: __SCREAMING_SNAKE_CASE = first_tensor.shape[0] if 0 < observed_batch_size < self.loader_batch_size: # could be last batch so we can't unroll as many # elements. __SCREAMING_SNAKE_CASE = observed_batch_size # Setting internal index to unwrap the batch __SCREAMING_SNAKE_CASE = processed __SCREAMING_SNAKE_CASE = 0 return self.loader_batch_item() else: # We're not unrolling batches return processed class UpperCAmelCase_ ( UpperCamelCase_ ): '''simple docstring''' def __init__( self , _A , _A , _A , _A=None ): '''simple docstring''' super().__init__(_A , _A , _A ) def __iter__( self ): '''simple docstring''' __SCREAMING_SNAKE_CASE = iter(self.loader ) __SCREAMING_SNAKE_CASE = None return self def _A ( self ): '''simple docstring''' if self.subiterator is None: __SCREAMING_SNAKE_CASE = self.infer(next(self.iterator ) , **self.params ) try: # Try to return next item __SCREAMING_SNAKE_CASE = next(self.subiterator ) except StopIteration: # When a preprocess iterator ends, we can start lookig at the next item # ChunkIterator will keep feeding until ALL elements of iterator # all have created their subiterator and have been iterating against. # # Another way to look at it, is we're basically flattening lists of lists # into a single list, but with generators __SCREAMING_SNAKE_CASE = self.infer(next(self.iterator ) , **self.params ) __SCREAMING_SNAKE_CASE = next(self.subiterator ) return processed class UpperCAmelCase_ ( UpperCamelCase_ ): '''simple docstring''' def __iter__( self ): '''simple docstring''' __SCREAMING_SNAKE_CASE = iter(self.loader ) return self def _A ( self ): '''simple docstring''' __SCREAMING_SNAKE_CASE = False __SCREAMING_SNAKE_CASE = [] if self._loader_batch_index is not None and self._loader_batch_index < self.loader_batch_size: while self._loader_batch_index < self.loader_batch_size: __SCREAMING_SNAKE_CASE = self.loader_batch_item() __SCREAMING_SNAKE_CASE = item.pop('is_last' ) accumulator.append(_A ) if is_last: return accumulator while not is_last: __SCREAMING_SNAKE_CASE = self.infer(next(self.iterator ) , **self.params ) if self.loader_batch_size is not None: if isinstance(_A , torch.Tensor ): __SCREAMING_SNAKE_CASE = processed else: __SCREAMING_SNAKE_CASE = list(processed.keys() )[0] __SCREAMING_SNAKE_CASE = processed[key] if isinstance(_A , _A ): __SCREAMING_SNAKE_CASE = len(_A ) else: __SCREAMING_SNAKE_CASE = first_tensor.shape[0] if 0 < observed_batch_size < self.loader_batch_size: # could be last batch so we can't unroll as many # elements. __SCREAMING_SNAKE_CASE = observed_batch_size __SCREAMING_SNAKE_CASE = processed __SCREAMING_SNAKE_CASE = 0 while self._loader_batch_index < self.loader_batch_size: __SCREAMING_SNAKE_CASE = self.loader_batch_item() __SCREAMING_SNAKE_CASE = item.pop('is_last' ) accumulator.append(_A ) if is_last: return accumulator else: __SCREAMING_SNAKE_CASE = processed __SCREAMING_SNAKE_CASE = item.pop('is_last' ) accumulator.append(_A ) return accumulator class UpperCAmelCase_ ( UpperCamelCase_ ): '''simple docstring''' def __init__( self , _A , _A ): '''simple docstring''' __SCREAMING_SNAKE_CASE = dataset __SCREAMING_SNAKE_CASE = key def __len__( self ): '''simple docstring''' return len(self.dataset ) def __getitem__( self , _A ): '''simple docstring''' return self.dataset[i][self.key] class UpperCAmelCase_ ( UpperCamelCase_ ): '''simple docstring''' def __init__( self , _A , _A , _A ): '''simple docstring''' __SCREAMING_SNAKE_CASE = dataset __SCREAMING_SNAKE_CASE = keya __SCREAMING_SNAKE_CASE = keya def __len__( self ): '''simple docstring''' return len(self.dataset ) def __getitem__( self , _A ): '''simple docstring''' return {"text": self.dataset[i][self.keya], "text_pair": self.dataset[i][self.keya]}
257
0
from typing import Dict, List, Optional, Union import numpy as np from .feature_extraction_utils import BatchFeature, FeatureExtractionMixin from .utils import PaddingStrategy, TensorType, is_tf_tensor, is_torch_tensor, logging, to_numpy a__ : Optional[Any] = logging.get_logger(__name__) class a_ ( a__ ): """simple docstring""" def __init__( self , _lowerCamelCase , _lowerCamelCase , _lowerCamelCase , **_lowerCamelCase ) ->List[str]: SCREAMING_SNAKE_CASE : str = feature_size SCREAMING_SNAKE_CASE : Union[str, Any] = sampling_rate SCREAMING_SNAKE_CASE : Union[str, Any] = padding_value SCREAMING_SNAKE_CASE : int = kwargs.pop('''padding_side''' , '''right''' ) SCREAMING_SNAKE_CASE : int = kwargs.pop('''return_attention_mask''' , _lowerCamelCase ) super().__init__(**_lowerCamelCase ) def __lowerCAmelCase ( self , _lowerCamelCase , _lowerCamelCase = True , _lowerCamelCase = None , _lowerCamelCase = False , _lowerCamelCase = None , _lowerCamelCase = None , _lowerCamelCase = None , ) ->BatchFeature: # If we have a list of dicts, let's convert it in a dict of lists # We do this to allow using this method as a collate_fn function in PyTorch Dataloader if isinstance(_lowerCamelCase , (list, tuple) ) and isinstance(processed_features[0] , (dict, BatchFeature) ): SCREAMING_SNAKE_CASE : Tuple = { key: [example[key] for example in processed_features] for key in processed_features[0].keys() } # The model's main input name, usually `input_values`, has be passed for padding if self.model_input_names[0] not in processed_features: raise ValueError( '''You should supply an instance of `transformers.BatchFeature` or list of `transformers.BatchFeature`''' F""" to this method that includes {self.model_input_names[0]}, but you provided""" F""" {list(processed_features.keys() )}""" ) SCREAMING_SNAKE_CASE : Dict = processed_features[self.model_input_names[0]] SCREAMING_SNAKE_CASE : Tuple = ( return_attention_mask if return_attention_mask is not None else self.return_attention_mask ) if len(_lowerCamelCase ) == 0: if return_attention_mask: SCREAMING_SNAKE_CASE : Union[str, Any] = [] return processed_features # If we have PyTorch/TF tensors or lists as inputs, we cast them as Numpy arrays # and rebuild them afterwards if no return_tensors is specified # Note that we lose the specific device the tensor may be on for PyTorch SCREAMING_SNAKE_CASE : int = required_input[0] if isinstance(_lowerCamelCase , (list, tuple) ): # first_element might be an empty list/tuple in some edge cases so we grab the first non empty element. SCREAMING_SNAKE_CASE : int = 0 while len(required_input[index] ) == 0: index += 1 if index < len(_lowerCamelCase ): SCREAMING_SNAKE_CASE : List[str] = required_input[index][0] if return_tensors is None: if is_tf_tensor(_lowerCamelCase ): SCREAMING_SNAKE_CASE : str = '''tf''' elif is_torch_tensor(_lowerCamelCase ): SCREAMING_SNAKE_CASE : Optional[Any] = '''pt''' elif isinstance(_lowerCamelCase , (int, float, list, tuple, np.ndarray) ): SCREAMING_SNAKE_CASE : List[Any] = '''np''' else: raise ValueError( F"""type of {first_element} unknown: {type(_lowerCamelCase )}. """ '''Should be one of a python, numpy, pytorch or tensorflow object.''' ) for key, value in processed_features.items(): if isinstance(value[0] , (int, float) ): SCREAMING_SNAKE_CASE : Optional[Any] = to_numpy(_lowerCamelCase ) else: SCREAMING_SNAKE_CASE : Optional[Any] = [to_numpy(_lowerCamelCase ) for v in value] # Convert padding_strategy in PaddingStrategy SCREAMING_SNAKE_CASE : Dict = self._get_padding_strategies(padding=_lowerCamelCase , max_length=_lowerCamelCase ) SCREAMING_SNAKE_CASE : Union[str, Any] = processed_features[self.model_input_names[0]] SCREAMING_SNAKE_CASE : Optional[int] = len(_lowerCamelCase ) if not all(len(_lowerCamelCase ) == batch_size for v in processed_features.values() ): raise ValueError('''Some items in the output dictionary have a different batch size than others.''' ) SCREAMING_SNAKE_CASE : Tuple = [] for i in range(_lowerCamelCase ): SCREAMING_SNAKE_CASE : Any = {k: v[i] for k, v in processed_features.items()} # truncation SCREAMING_SNAKE_CASE : List[str] = self._truncate( _lowerCamelCase , max_length=_lowerCamelCase , pad_to_multiple_of=_lowerCamelCase , truncation=_lowerCamelCase , ) truncated_inputs.append(_lowerCamelCase ) if padding_strategy == PaddingStrategy.LONGEST: # make sure that `max_length` cannot be longer than the longest truncated length SCREAMING_SNAKE_CASE : List[str] = max(len(input_slice[self.model_input_names[0]] ) for input_slice in truncated_inputs ) SCREAMING_SNAKE_CASE : Optional[int] = PaddingStrategy.MAX_LENGTH SCREAMING_SNAKE_CASE : Tuple = {} for i in range(_lowerCamelCase ): # padding SCREAMING_SNAKE_CASE : Tuple = self._pad( truncated_inputs[i] , max_length=_lowerCamelCase , padding_strategy=_lowerCamelCase , pad_to_multiple_of=_lowerCamelCase , return_attention_mask=_lowerCamelCase , ) for key, value in outputs.items(): if key not in batch_outputs: SCREAMING_SNAKE_CASE : Optional[int] = [] if value.dtype is np.dtype(np.floataa ): SCREAMING_SNAKE_CASE : Optional[Any] = value.astype(np.floataa ) batch_outputs[key].append(_lowerCamelCase ) return BatchFeature(_lowerCamelCase , tensor_type=_lowerCamelCase ) def __lowerCAmelCase ( self , _lowerCamelCase , _lowerCamelCase = None , _lowerCamelCase = PaddingStrategy.DO_NOT_PAD , _lowerCamelCase = None , _lowerCamelCase = None , ) ->dict: SCREAMING_SNAKE_CASE : int = processed_features[self.model_input_names[0]] if padding_strategy == PaddingStrategy.LONGEST: SCREAMING_SNAKE_CASE : Dict = len(_lowerCamelCase ) if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0): SCREAMING_SNAKE_CASE : Optional[int] = ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of SCREAMING_SNAKE_CASE : int = padding_strategy != PaddingStrategy.DO_NOT_PAD and len(_lowerCamelCase ) < max_length if return_attention_mask and "attention_mask" not in processed_features: SCREAMING_SNAKE_CASE : List[str] = np.ones(len(_lowerCamelCase ) , dtype=np.intaa ) if needs_to_be_padded: SCREAMING_SNAKE_CASE : Optional[int] = max_length - len(_lowerCamelCase ) if self.padding_side == "right": if return_attention_mask: SCREAMING_SNAKE_CASE : str = np.pad( processed_features['''attention_mask'''] , (0, difference) ) SCREAMING_SNAKE_CASE : Optional[int] = ((0, difference), (0, 0)) if self.feature_size > 1 else (0, difference) SCREAMING_SNAKE_CASE : Tuple = np.pad( _lowerCamelCase , _lowerCamelCase , '''constant''' , constant_values=self.padding_value ) elif self.padding_side == "left": if return_attention_mask: SCREAMING_SNAKE_CASE : Union[str, Any] = np.pad( processed_features['''attention_mask'''] , (difference, 0) ) SCREAMING_SNAKE_CASE : str = ((difference, 0), (0, 0)) if self.feature_size > 1 else (difference, 0) SCREAMING_SNAKE_CASE : List[str] = np.pad( _lowerCamelCase , _lowerCamelCase , '''constant''' , constant_values=self.padding_value ) else: raise ValueError('''Invalid padding strategy:''' + str(self.padding_side ) ) return processed_features def __lowerCAmelCase ( self , _lowerCamelCase , _lowerCamelCase = None , _lowerCamelCase = None , _lowerCamelCase = None , ) ->Optional[Any]: if not truncation: return processed_features elif truncation and max_length is None: raise ValueError('''When setting ``truncation=True``, make sure that ``max_length`` is defined.''' ) SCREAMING_SNAKE_CASE : Dict = processed_features[self.model_input_names[0]] # find `max_length` that fits `pad_to_multiple_of` if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0): SCREAMING_SNAKE_CASE : int = ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of SCREAMING_SNAKE_CASE : Optional[Any] = len(_lowerCamelCase ) > max_length if needs_to_be_truncated: SCREAMING_SNAKE_CASE : int = processed_features[self.model_input_names[0]][:max_length] if "attention_mask" in processed_features: SCREAMING_SNAKE_CASE : List[Any] = processed_features['''attention_mask'''][:max_length] return processed_features def __lowerCAmelCase ( self , _lowerCamelCase=False , _lowerCamelCase=None ) ->List[Any]: # Get padding strategy if padding is not False: if padding is True: SCREAMING_SNAKE_CASE : Any = PaddingStrategy.LONGEST # Default to pad to the longest sequence in the batch elif not isinstance(_lowerCamelCase , _lowerCamelCase ): SCREAMING_SNAKE_CASE : Optional[Any] = PaddingStrategy(_lowerCamelCase ) elif isinstance(_lowerCamelCase , _lowerCamelCase ): SCREAMING_SNAKE_CASE : str = padding else: SCREAMING_SNAKE_CASE : Union[str, Any] = PaddingStrategy.DO_NOT_PAD # Set max length if needed if max_length is None: if padding_strategy == PaddingStrategy.MAX_LENGTH: raise ValueError( F"""When setting ``padding={PaddingStrategy.MAX_LENGTH}``, make sure that max_length is defined""" ) # Test if we have a padding value if padding_strategy != PaddingStrategy.DO_NOT_PAD and (self.padding_value is None): raise ValueError( '''Asking to pad but the feature_extractor does not have a padding value. Please select a value to use''' ''' as `padding_value`. For example: `feature_extractor.padding_value = 0.0`.''' ) return padding_strategy
19
import gc import unittest import numpy as np import torch from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer from diffusers import ( AutoencoderKL, DDIMScheduler, StableDiffusionSAGPipeline, UNetaDConditionModel, ) from diffusers.utils import slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin enable_full_determinism() class a_ ( a__ , a__ , unittest.TestCase ): """simple docstring""" __SCREAMING_SNAKE_CASE : Tuple = StableDiffusionSAGPipeline __SCREAMING_SNAKE_CASE : Dict = TEXT_TO_IMAGE_PARAMS __SCREAMING_SNAKE_CASE : Tuple = TEXT_TO_IMAGE_BATCH_PARAMS __SCREAMING_SNAKE_CASE : List[Any] = TEXT_TO_IMAGE_IMAGE_PARAMS __SCREAMING_SNAKE_CASE : Union[str, Any] = TEXT_TO_IMAGE_IMAGE_PARAMS __SCREAMING_SNAKE_CASE : int = False def __lowerCAmelCase ( self ) ->Optional[int]: torch.manual_seed(0 ) SCREAMING_SNAKE_CASE : Tuple = UNetaDConditionModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=4 , out_channels=4 , down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''') , up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''') , cross_attention_dim=32 , ) SCREAMING_SNAKE_CASE : int = DDIMScheduler( beta_start=0.0_0_0_8_5 , beta_end=0.0_1_2 , beta_schedule='''scaled_linear''' , clip_sample=_lowerCamelCase , set_alpha_to_one=_lowerCamelCase , ) torch.manual_seed(0 ) SCREAMING_SNAKE_CASE : str = AutoencoderKL( block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D'''] , up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D'''] , latent_channels=4 , ) torch.manual_seed(0 ) SCREAMING_SNAKE_CASE : Dict = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1000 , ) SCREAMING_SNAKE_CASE : Union[str, Any] = CLIPTextModel(_lowerCamelCase ) SCREAMING_SNAKE_CASE : str = CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''' ) SCREAMING_SNAKE_CASE : Union[str, Any] = { '''unet''': unet, '''scheduler''': scheduler, '''vae''': vae, '''text_encoder''': text_encoder, '''tokenizer''': tokenizer, '''safety_checker''': None, '''feature_extractor''': None, } return components def __lowerCAmelCase ( self , _lowerCamelCase , _lowerCamelCase=0 ) ->str: if str(_lowerCamelCase ).startswith('''mps''' ): SCREAMING_SNAKE_CASE : List[Any] = torch.manual_seed(_lowerCamelCase ) else: SCREAMING_SNAKE_CASE : List[Any] = torch.Generator(device=_lowerCamelCase ).manual_seed(_lowerCamelCase ) SCREAMING_SNAKE_CASE : str = { '''prompt''': '''.''', '''generator''': generator, '''num_inference_steps''': 2, '''guidance_scale''': 1.0, '''sag_scale''': 1.0, '''output_type''': '''numpy''', } return inputs def __lowerCAmelCase ( self ) ->Optional[int]: super().test_inference_batch_single_identical(expected_max_diff=3e-3 ) @slow @require_torch_gpu class a_ ( unittest.TestCase ): """simple docstring""" def __lowerCAmelCase ( self ) ->Dict: # clean up the VRAM after each test super().tearDown() gc.collect() torch.cuda.empty_cache() def __lowerCAmelCase ( self ) ->Union[str, Any]: SCREAMING_SNAKE_CASE : Optional[Any] = StableDiffusionSAGPipeline.from_pretrained('''CompVis/stable-diffusion-v1-4''' ) SCREAMING_SNAKE_CASE : Tuple = sag_pipe.to(_lowerCamelCase ) sag_pipe.set_progress_bar_config(disable=_lowerCamelCase ) SCREAMING_SNAKE_CASE : List[str] = '''.''' SCREAMING_SNAKE_CASE : Dict = torch.manual_seed(0 ) SCREAMING_SNAKE_CASE : List[str] = sag_pipe( [prompt] , generator=_lowerCamelCase , guidance_scale=7.5 , sag_scale=1.0 , num_inference_steps=20 , output_type='''np''' ) SCREAMING_SNAKE_CASE : int = output.images SCREAMING_SNAKE_CASE : Any = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE : Optional[int] = np.array([0.1_5_6_8, 0.1_7_3_8, 0.1_6_9_5, 0.1_6_9_3, 0.1_5_0_7, 0.1_7_0_5, 0.1_5_4_7, 0.1_7_5_1, 0.1_9_4_9] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 5e-2 def __lowerCAmelCase ( self ) ->Optional[int]: SCREAMING_SNAKE_CASE : Union[str, Any] = StableDiffusionSAGPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base''' ) SCREAMING_SNAKE_CASE : int = sag_pipe.to(_lowerCamelCase ) sag_pipe.set_progress_bar_config(disable=_lowerCamelCase ) SCREAMING_SNAKE_CASE : Dict = '''.''' SCREAMING_SNAKE_CASE : str = torch.manual_seed(0 ) SCREAMING_SNAKE_CASE : Any = sag_pipe( [prompt] , generator=_lowerCamelCase , guidance_scale=7.5 , sag_scale=1.0 , num_inference_steps=20 , output_type='''np''' ) SCREAMING_SNAKE_CASE : List[str] = output.images SCREAMING_SNAKE_CASE : List[Any] = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE : str = np.array([0.3_4_5_9, 0.2_8_7_6, 0.2_5_3_7, 0.3_0_0_2, 0.2_6_7_1, 0.2_1_6_0, 0.3_0_2_6, 0.2_2_6_2, 0.2_3_7_1] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 5e-2 def __lowerCAmelCase ( self ) ->Any: SCREAMING_SNAKE_CASE : int = StableDiffusionSAGPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base''' ) SCREAMING_SNAKE_CASE : Optional[int] = sag_pipe.to(_lowerCamelCase ) sag_pipe.set_progress_bar_config(disable=_lowerCamelCase ) SCREAMING_SNAKE_CASE : int = '''.''' SCREAMING_SNAKE_CASE : Optional[Any] = torch.manual_seed(0 ) SCREAMING_SNAKE_CASE : List[str] = sag_pipe( [prompt] , width=768 , height=512 , generator=_lowerCamelCase , guidance_scale=7.5 , sag_scale=1.0 , num_inference_steps=20 , output_type='''np''' , ) SCREAMING_SNAKE_CASE : List[Any] = output.images assert image.shape == (1, 512, 768, 3)
19
1
import os from shutil import copyfile from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging __A = logging.get_logger(__name__) __A = "▁" __A = {"vocab_file": "sentencepiece.bpe.model"} __A = { "vocab_file": { "facebook/xglm-564M": "https://huggingface.co/facebook/xglm-564M/resolve/main/sentencepiece.bpe.model", } } __A = { "facebook/xglm-564M": 2048, } class _SCREAMING_SNAKE_CASE ( __SCREAMING_SNAKE_CASE ): '''simple docstring''' lowercase_ = VOCAB_FILES_NAMES lowercase_ = PRETRAINED_VOCAB_FILES_MAP lowercase_ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ = ["input_ids", "attention_mask"] def __init__(self : List[Any] , UpperCAmelCase_ : List[Any] , UpperCAmelCase_ : Any="<s>" , UpperCAmelCase_ : Optional[int]="</s>" , UpperCAmelCase_ : List[Any]="</s>" , UpperCAmelCase_ : Union[str, Any]="<s>" , UpperCAmelCase_ : Any="<unk>" , UpperCAmelCase_ : str="<pad>" , UpperCAmelCase_ : Optional[Dict[str, Any]] = None , **UpperCAmelCase_ : str , ) ->None: '''simple docstring''' lowerCamelCase__: Dict ={} if sp_model_kwargs is None else sp_model_kwargs # Compatibility with the original tokenizer lowerCamelCase__: Tuple =7 lowerCamelCase__: int =[F"""<madeupword{i}>""" for i in range(self.num_madeup_words)] lowerCamelCase__: str =kwargs.get("additional_special_tokens" , []) kwargs["additional_special_tokens"] += [ word for word in madeup_words if word not in kwargs["additional_special_tokens"] ] super().__init__( bos_token=UpperCAmelCase_ , eos_token=UpperCAmelCase_ , unk_token=UpperCAmelCase_ , sep_token=UpperCAmelCase_ , cls_token=UpperCAmelCase_ , pad_token=UpperCAmelCase_ , sp_model_kwargs=self.sp_model_kwargs , **UpperCAmelCase_ , ) lowerCamelCase__: Any =spm.SentencePieceProcessor(**self.sp_model_kwargs) self.sp_model.Load(str(UpperCAmelCase_)) lowerCamelCase__: List[str] =vocab_file # Original fairseq vocab and spm vocab must be "aligned": # Vocab | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 # -------- | ------- | ------- | ------ | ------- | --- | --- | --- | ----- | ----- | ---- # fairseq | '<s>' | '<pad>' | '</s>' | '<unk>' | ',' | '.' | '▁' | 's' | '▁de' | '-' # spm | '<unk>' | '<s>' | '</s>' | ',' | '.' | '▁' | 's' | '▁de' | '-' | '▁a' # The first "real" token "," has position 4 in the original fairseq vocab and position 3 in the spm vocab lowerCamelCase__: Union[str, Any] =1 # Mimic fairseq token-to-id alignment for the first 4 token lowerCamelCase__: Union[str, Any] ={"<s>": 0, "<pad>": 1, "</s>": 2, "<unk>": 3} lowerCamelCase__: Any =len(self.sp_model) lowerCamelCase__: Tuple ={F"""<madeupword{i}>""": sp_size + i + self.fairseq_offset for i in range(self.num_madeup_words)} self.fairseq_tokens_to_ids.update(UpperCAmelCase_) lowerCamelCase__: int ={v: k for k, v in self.fairseq_tokens_to_ids.items()} def __getstate__(self : Dict) ->List[str]: '''simple docstring''' lowerCamelCase__: List[Any] =self.__dict__.copy() lowerCamelCase__: str =None lowerCamelCase__: Any =self.sp_model.serialized_model_proto() return state def __setstate__(self : Any , UpperCAmelCase_ : Tuple) ->Optional[int]: '''simple docstring''' lowerCamelCase__: Optional[Any] =d # for backward compatibility if not hasattr(self , "sp_model_kwargs"): lowerCamelCase__: int ={} lowerCamelCase__: str =spm.SentencePieceProcessor(**self.sp_model_kwargs) self.sp_model.LoadFromSerializedProto(self.sp_model_proto) def SCREAMING_SNAKE_CASE_ (self : List[str] , UpperCAmelCase_ : List[int] , UpperCAmelCase_ : Optional[List[int]] = None) ->List[int]: '''simple docstring''' if token_ids_a is None: return [self.sep_token_id] + token_ids_a lowerCamelCase__: Any =[self.sep_token_id] return sep + token_ids_a + sep + sep + token_ids_a def SCREAMING_SNAKE_CASE_ (self : int , UpperCAmelCase_ : List[int] , UpperCAmelCase_ : Optional[List[int]] = None , UpperCAmelCase_ : bool = False) ->List[int]: '''simple docstring''' if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=UpperCAmelCase_ , token_ids_a=UpperCAmelCase_ , already_has_special_tokens=UpperCAmelCase_) if token_ids_a is None: return [1] + ([0] * len(UpperCAmelCase_)) return [1] + ([0] * len(UpperCAmelCase_)) + [1, 1] + ([0] * len(UpperCAmelCase_)) def SCREAMING_SNAKE_CASE_ (self : Dict , UpperCAmelCase_ : List[int] , UpperCAmelCase_ : Optional[List[int]] = None) ->List[int]: '''simple docstring''' lowerCamelCase__: List[str] =[self.sep_token_id] if token_ids_a is None: return len(sep + token_ids_a) * [0] return len(sep + token_ids_a + sep + sep + token_ids_a) * [0] @property def SCREAMING_SNAKE_CASE_ (self : List[Any]) ->Optional[int]: '''simple docstring''' return len(self.sp_model) + self.fairseq_offset + self.num_madeup_words def SCREAMING_SNAKE_CASE_ (self : int) ->str: '''simple docstring''' lowerCamelCase__: str ={self.convert_ids_to_tokens(UpperCAmelCase_): i for i in range(self.vocab_size)} vocab.update(self.added_tokens_encoder) return vocab def SCREAMING_SNAKE_CASE_ (self : Any , UpperCAmelCase_ : str) ->List[str]: '''simple docstring''' return self.sp_model.encode(UpperCAmelCase_ , out_type=UpperCAmelCase_) def SCREAMING_SNAKE_CASE_ (self : List[str] , UpperCAmelCase_ : Union[str, Any]) ->Dict: '''simple docstring''' if token in self.fairseq_tokens_to_ids: return self.fairseq_tokens_to_ids[token] lowerCamelCase__: Optional[int] =self.sp_model.PieceToId(UpperCAmelCase_) # Need to return unknown token if the SP model returned 0 return spm_id + self.fairseq_offset if spm_id else self.unk_token_id def SCREAMING_SNAKE_CASE_ (self : List[str] , UpperCAmelCase_ : List[str]) ->Optional[Any]: '''simple docstring''' if index in self.fairseq_ids_to_tokens: return self.fairseq_ids_to_tokens[index] return self.sp_model.IdToPiece(index - self.fairseq_offset) def SCREAMING_SNAKE_CASE_ (self : Any , UpperCAmelCase_ : Dict) ->Dict: '''simple docstring''' lowerCamelCase__: str ="".join(UpperCAmelCase_).replace(UpperCAmelCase_ , " ").strip() return out_string def SCREAMING_SNAKE_CASE_ (self : Dict , UpperCAmelCase_ : str , UpperCAmelCase_ : Optional[str] = None) ->Tuple[str]: '''simple docstring''' if not os.path.isdir(UpperCAmelCase_): logger.error(F"""Vocabulary path ({save_directory}) should be a directory""") return lowerCamelCase__: List[str] =os.path.join( UpperCAmelCase_ , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]) if os.path.abspath(self.vocab_file) != os.path.abspath(UpperCAmelCase_) and os.path.isfile(self.vocab_file): copyfile(self.vocab_file , UpperCAmelCase_) elif not os.path.isfile(self.vocab_file): with open(UpperCAmelCase_ , "wb") as fi: lowerCamelCase__: Optional[int] =self.sp_model.serialized_model_proto() fi.write(UpperCAmelCase_) return (out_vocab_file,)
10
'''simple docstring''' from __future__ import annotations import unittest from transformers import EsmConfig, is_tf_available from transformers.testing_utils import require_tf, slow from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import numpy import tensorflow as tf from transformers.models.esm.modeling_tf_esm import ( TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST, TFEsmForMaskedLM, TFEsmForSequenceClassification, TFEsmForTokenClassification, TFEsmModel, ) class snake_case : """simple docstring""" def __init__( self , UpperCamelCase , ): """simple docstring""" lowerCamelCase_ = parent lowerCamelCase_ = 13 lowerCamelCase_ = 7 lowerCamelCase_ = True lowerCamelCase_ = True lowerCamelCase_ = True lowerCamelCase_ = 99 lowerCamelCase_ = 32 lowerCamelCase_ = 2 lowerCamelCase_ = 4 lowerCamelCase_ = 37 lowerCamelCase_ = "gelu" lowerCamelCase_ = 0.1 lowerCamelCase_ = 0.1 lowerCamelCase_ = 512 lowerCamelCase_ = 16 lowerCamelCase_ = 2 lowerCamelCase_ = 0.02 lowerCamelCase_ = 3 lowerCamelCase_ = 4 lowerCamelCase_ = None def snake_case ( self ): """simple docstring""" lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) lowerCamelCase_ = None if self.use_input_mask: lowerCamelCase_ = random_attention_mask([self.batch_size, self.seq_length] ) lowerCamelCase_ = None lowerCamelCase_ = None lowerCamelCase_ = None if self.use_labels: lowerCamelCase_ = ids_tensor([self.batch_size] , self.type_sequence_label_size ) lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) lowerCamelCase_ = ids_tensor([self.batch_size] , self.num_choices ) lowerCamelCase_ = EsmConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , pad_token_id=1 , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , initializer_range=self.initializer_range , ) return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels def snake_case ( self ): """simple docstring""" ( ( lowerCamelCase_ ) ,( lowerCamelCase_ ) ,( lowerCamelCase_ ) ,( lowerCamelCase_ ) ,( lowerCamelCase_ ) ,( lowerCamelCase_ ) , ) = self.prepare_config_and_inputs() lowerCamelCase_ = True lowerCamelCase_ = floats_tensor([self.batch_size, self.seq_length, self.hidden_size] ) lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , vocab_size=2 ) return ( config, input_ids, input_mask, sequence_labels, token_labels, choice_labels, encoder_hidden_states, encoder_attention_mask, ) def snake_case ( self , UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase ): """simple docstring""" lowerCamelCase_ = TFEsmModel(config=UpperCamelCase ) lowerCamelCase_ = {"input_ids": input_ids, "attention_mask": input_mask} lowerCamelCase_ = model(UpperCamelCase ) lowerCamelCase_ = [input_ids, input_mask] lowerCamelCase_ = model(UpperCamelCase ) lowerCamelCase_ = model(UpperCamelCase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def snake_case ( self , UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase , ): """simple docstring""" lowerCamelCase_ = True lowerCamelCase_ = TFEsmModel(config=UpperCamelCase ) lowerCamelCase_ = { "input_ids": input_ids, "attention_mask": input_mask, "encoder_hidden_states": encoder_hidden_states, "encoder_attention_mask": encoder_attention_mask, } lowerCamelCase_ = model(UpperCamelCase ) lowerCamelCase_ = [input_ids, input_mask] lowerCamelCase_ = model(UpperCamelCase , encoder_hidden_states=UpperCamelCase ) # Also check the case where encoder outputs are not passed lowerCamelCase_ = model(UpperCamelCase , attention_mask=UpperCamelCase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def snake_case ( self , UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase ): """simple docstring""" lowerCamelCase_ = TFEsmForMaskedLM(config=UpperCamelCase ) lowerCamelCase_ = model([input_ids, input_mask] ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def snake_case ( self , UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase ): """simple docstring""" lowerCamelCase_ = self.num_labels lowerCamelCase_ = TFEsmForTokenClassification(config=UpperCamelCase ) lowerCamelCase_ = {"input_ids": input_ids, "attention_mask": input_mask} lowerCamelCase_ = model(UpperCamelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def snake_case ( self ): """simple docstring""" lowerCamelCase_ = self.prepare_config_and_inputs() ( ( lowerCamelCase_ ) ,( lowerCamelCase_ ) ,( lowerCamelCase_ ) ,( lowerCamelCase_ ) ,( lowerCamelCase_ ) ,( lowerCamelCase_ ) , ) = config_and_inputs lowerCamelCase_ = {"input_ids": input_ids, "attention_mask": input_mask} return config, inputs_dict @require_tf class snake_case ( lowercase , lowercase , unittest.TestCase ): """simple docstring""" _lowerCamelCase = ( ( TFEsmModel, TFEsmForMaskedLM, TFEsmForSequenceClassification, TFEsmForTokenClassification, ) if is_tf_available() else () ) _lowerCamelCase = ( { "feature-extraction": TFEsmModel, "fill-mask": TFEsmForMaskedLM, "text-classification": TFEsmForSequenceClassification, "token-classification": TFEsmForTokenClassification, "zero-shot": TFEsmForSequenceClassification, } if is_tf_available() else {} ) _lowerCamelCase = False _lowerCamelCase = False def snake_case ( self ): """simple docstring""" lowerCamelCase_ = TFEsmModelTester(self ) lowerCamelCase_ = ConfigTester(self , config_class=UpperCamelCase , hidden_size=37 ) def snake_case ( self ): """simple docstring""" self.config_tester.run_common_tests() def snake_case ( self ): """simple docstring""" lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*UpperCamelCase ) def snake_case ( self ): """simple docstring""" lowerCamelCase_ = self.model_tester.prepare_config_and_inputs_for_decoder() self.model_tester.create_and_check_model_as_decoder(*UpperCamelCase ) def snake_case ( self ): """simple docstring""" lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*UpperCamelCase ) def snake_case ( self ): """simple docstring""" lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*UpperCamelCase ) @slow def snake_case ( self ): """simple docstring""" for model_name in TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: lowerCamelCase_ = TFEsmModel.from_pretrained(UpperCamelCase ) self.assertIsNotNone(UpperCamelCase ) @unittest.skip("Protein models do not support embedding resizing." ) def snake_case ( self ): """simple docstring""" pass @unittest.skip("Protein models do not support embedding resizing." ) def snake_case ( self ): """simple docstring""" pass def snake_case ( self ): """simple docstring""" lowerCamelCase_ ,lowerCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: lowerCamelCase_ = model_class(UpperCamelCase ) assert isinstance(model.get_input_embeddings() , tf.keras.layers.Layer ) if model_class is TFEsmForMaskedLM: # Output embedding test differs from the main test because they're a matrix, not a layer lowerCamelCase_ = model.get_bias() assert isinstance(UpperCamelCase , UpperCamelCase ) for k, v in name.items(): assert isinstance(UpperCamelCase , tf.Variable ) else: lowerCamelCase_ = model.get_output_embeddings() assert x is None lowerCamelCase_ = model.get_bias() assert name is None @require_tf class snake_case ( unittest.TestCase ): """simple docstring""" @slow def snake_case ( self ): """simple docstring""" lowerCamelCase_ = TFEsmForMaskedLM.from_pretrained("facebook/esm2_t6_8M_UR50D" ) lowerCamelCase_ = tf.constant([[0, 1, 2, 3, 4, 5]] ) lowerCamelCase_ = model(UpperCamelCase )[0] lowerCamelCase_ = [1, 6, 33] self.assertEqual(list(output.numpy().shape ) , UpperCamelCase ) # compare the actual values for a slice. lowerCamelCase_ = tf.constant( [ [ [8.921_518, -10.589_814, -6.4_671_307], [-6.3_967_156, -13.911_377, -1.1_211_915], [-7.781_247, -13.951_557, -3.740_592], ] ] ) self.assertTrue(numpy.allclose(output[:, :3, :3].numpy() , expected_slice.numpy() , atol=1e-2 ) ) @slow def snake_case ( self ): """simple docstring""" lowerCamelCase_ = TFEsmModel.from_pretrained("facebook/esm2_t6_8M_UR50D" ) lowerCamelCase_ = tf.constant([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]] ) lowerCamelCase_ = model(UpperCamelCase )[0] # compare the actual values for a slice. lowerCamelCase_ = tf.constant( [ [ [0.14_443_092, 0.54_125_327, 0.3_247_739], [0.30_340_484, 0.00_526_676, 0.31_077_722], [0.32_278_043, -0.24_987_096, 0.3_414_628], ] ] ) self.assertTrue(numpy.allclose(output[:, :3, :3].numpy() , expected_slice.numpy() , atol=1e-4 ) )
55
0
"""simple docstring""" from argparse import ArgumentParser from . import BaseTransformersCLICommand def snake_case (A_ :Any ): '''simple docstring''' return DownloadCommand(args.model , args.cache_dir , args.force , args.trust_remote_code ) class snake_case ( __lowerCamelCase ): @staticmethod def lowerCamelCase__ ( A : ArgumentParser ): '''simple docstring''' a : int = parser.add_parser('download' ) download_parser.add_argument( '--cache-dir' , type=__lowercase , default=__lowercase , help='Path to location to store the models' ) download_parser.add_argument( '--force' , action='store_true' , help='Force the model to be download even if already in cache-dir' ) download_parser.add_argument( '--trust-remote-code' , action='store_true' , help='Whether or not to allow for custom models defined on the Hub in their own modeling files. Use only if you\'ve reviewed the code as it will execute on your local machine' , ) download_parser.add_argument('model' , type=__lowercase , help='Name of the model to download' ) download_parser.set_defaults(func=__lowercase ) def __init__( self : Any , A : str , A : str , A : bool , A : bool ): '''simple docstring''' a : Union[str, Any] = model a : Union[str, Any] = cache a : Dict = force a : List[str] = trust_remote_code def lowerCamelCase__ ( self : str ): '''simple docstring''' from ..models.auto import AutoModel, AutoTokenizer AutoModel.from_pretrained( self._model , cache_dir=self._cache , force_download=self._force , trust_remote_code=self._trust_remote_code ) AutoTokenizer.from_pretrained( self._model , cache_dir=self._cache , force_download=self._force , trust_remote_code=self._trust_remote_code )
350
"""simple docstring""" import os import unittest from transformers.models.bartpho.tokenization_bartpho import VOCAB_FILES_NAMES, BartphoTokenizer from transformers.testing_utils import get_tests_dir from ...test_tokenization_common import TokenizerTesterMixin _UpperCamelCase : int = get_tests_dir('fixtures/test_sentencepiece_bpe.model') class snake_case ( UpperCAmelCase , unittest.TestCase ): __magic_name__ = BartphoTokenizer __magic_name__ = False __magic_name__ = True def lowerCamelCase__ ( self : List[Any] ): '''simple docstring''' super().setUp() a : Any = ['▁This', '▁is', '▁a', '▁t', 'est'] a : List[Any] = dict(zip(A , range(len(A ) ) ) ) a : int = {'unk_token': '<unk>'} a : Tuple = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['monolingual_vocab_file'] ) with open(self.monolingual_vocab_file , 'w' , encoding='utf-8' ) as fp: for token in vocab_tokens: fp.write(F'''{token} {vocab_tokens[token]}\n''' ) a : Optional[int] = BartphoTokenizer(A , self.monolingual_vocab_file , **self.special_tokens_map ) tokenizer.save_pretrained(self.tmpdirname ) def lowerCamelCase__ ( self : Dict , **A : str ): '''simple docstring''' kwargs.update(self.special_tokens_map ) return BartphoTokenizer.from_pretrained(self.tmpdirname , **A ) def lowerCamelCase__ ( self : Optional[int] , A : Dict ): '''simple docstring''' a : Tuple = 'This is a là test' a : List[Any] = 'This is a<unk><unk> test' return input_text, output_text def lowerCamelCase__ ( self : Optional[Any] ): '''simple docstring''' a : Tuple = BartphoTokenizer(A , self.monolingual_vocab_file , **self.special_tokens_map ) a : int = 'This is a là test' a : int = '▁This ▁is ▁a ▁l à ▁t est'.split() a : str = tokenizer.tokenize(A ) self.assertListEqual(A , A ) a : Union[str, Any] = tokens + [tokenizer.unk_token] a : Dict = [4, 5, 6, 3, 3, 7, 8, 3] self.assertListEqual(tokenizer.convert_tokens_to_ids(A ) , A )
186
0
import argparse import pickle import numpy as np import torch from torch import nn from transformers import ReformerConfig, ReformerModelWithLMHead from transformers.utils import logging logging.set_verbosity_info() def _UpperCamelCase ( lowercase__ , lowercase__ , lowercase__=None ): # set parameter of one layer assert torch_layer.weight.shape == weight.shape, F'''{torch_layer} layer.weight does not match''' __SCREAMING_SNAKE_CASE : str = nn.Parameter(SCREAMING_SNAKE_CASE__ ) if bias is not None: assert torch_layer.bias.shape == bias.shape, F'''{torch_layer} layer.bias does not match''' __SCREAMING_SNAKE_CASE : Tuple = nn.Parameter(SCREAMING_SNAKE_CASE__ ) def _UpperCamelCase ( lowercase__ , lowercase__ , lowercase__ ): # set torch weights for 1-to-1 comparison __SCREAMING_SNAKE_CASE : Optional[int] = np.asarray(weights[0] ) __SCREAMING_SNAKE_CASE : Tuple = np.asarray(weights[1] ) __SCREAMING_SNAKE_CASE : Optional[Any] = np.asarray(weights[2] ) set_param( torch_layer.self_attention.query_key , torch.tensor(SCREAMING_SNAKE_CASE__ ).transpose(1 , 2 ).contiguous().view(-1 , SCREAMING_SNAKE_CASE__ ) , ) set_param( torch_layer.self_attention.value , torch.tensor(SCREAMING_SNAKE_CASE__ ).transpose(1 , 2 ).contiguous().view(-1 , SCREAMING_SNAKE_CASE__ ) , ) set_param( torch_layer.output.dense , torch.tensor(SCREAMING_SNAKE_CASE__ ).view(-1 , SCREAMING_SNAKE_CASE__ ).contiguous().transpose(0 , 1 ) , ) def _UpperCamelCase ( lowercase__ , lowercase__ , lowercase__ ): # set torch weights for 1-to-1 comparison __SCREAMING_SNAKE_CASE : int = np.asarray(weights[0] ) __SCREAMING_SNAKE_CASE : Any = np.asarray(weights[1] ) __SCREAMING_SNAKE_CASE : List[str] = np.asarray(weights[2] ) __SCREAMING_SNAKE_CASE : List[str] = np.asarray(weights[3] ) set_param( torch_layer.self_attention.query , torch.tensor(SCREAMING_SNAKE_CASE__ ).transpose(1 , 2 ).contiguous().view(-1 , SCREAMING_SNAKE_CASE__ ) , ) set_param( torch_layer.self_attention.key , torch.tensor(SCREAMING_SNAKE_CASE__ ).transpose(1 , 2 ).contiguous().view(-1 , SCREAMING_SNAKE_CASE__ ) , ) set_param( torch_layer.self_attention.value , torch.tensor(SCREAMING_SNAKE_CASE__ ).transpose(1 , 2 ).contiguous().view(-1 , SCREAMING_SNAKE_CASE__ ) , ) set_param( torch_layer.output.dense , torch.tensor(SCREAMING_SNAKE_CASE__ ).view(-1 , SCREAMING_SNAKE_CASE__ ).contiguous().transpose(0 , 1 ) , ) def _UpperCamelCase ( lowercase__ , lowercase__ , lowercase__ ): # layernorm 1 __SCREAMING_SNAKE_CASE : List[Any] = weights[0][0][0] __SCREAMING_SNAKE_CASE : Union[str, Any] = np.asarray(layer_norm_a[0] ) __SCREAMING_SNAKE_CASE : str = np.asarray(layer_norm_a[1] ) set_param( torch_block.attention.layer_norm , torch.tensor(SCREAMING_SNAKE_CASE__ ) , torch.tensor(SCREAMING_SNAKE_CASE__ ) , ) # lsh weights + output __SCREAMING_SNAKE_CASE : int = weights[0][1] if len(SCREAMING_SNAKE_CASE__ ) < 4: set_layer_weights_in_torch_lsh(SCREAMING_SNAKE_CASE__ , torch_block.attention , SCREAMING_SNAKE_CASE__ ) else: set_layer_weights_in_torch_local(SCREAMING_SNAKE_CASE__ , torch_block.attention , SCREAMING_SNAKE_CASE__ ) # intermediate weighs __SCREAMING_SNAKE_CASE : Dict = weights[2][0][1][2] # Chunked Feed Forward if len(SCREAMING_SNAKE_CASE__ ) == 4: __SCREAMING_SNAKE_CASE : List[str] = intermediate_weights[2] # layernorm 2 __SCREAMING_SNAKE_CASE : Dict = np.asarray(intermediate_weights[0][0] ) __SCREAMING_SNAKE_CASE : Optional[Any] = np.asarray(intermediate_weights[0][1] ) set_param( torch_block.feed_forward.layer_norm , torch.tensor(SCREAMING_SNAKE_CASE__ ) , torch.tensor(SCREAMING_SNAKE_CASE__ ) , ) # intermediate dense __SCREAMING_SNAKE_CASE : str = np.asarray(intermediate_weights[1][0] ) __SCREAMING_SNAKE_CASE : Tuple = np.asarray(intermediate_weights[1][1] ) set_param( torch_block.feed_forward.dense.dense , torch.tensor(SCREAMING_SNAKE_CASE__ ).transpose(0 , 1 ).contiguous() , torch.tensor(SCREAMING_SNAKE_CASE__ ) , ) # intermediate out __SCREAMING_SNAKE_CASE : List[str] = np.asarray(intermediate_weights[4][0] ) __SCREAMING_SNAKE_CASE : Optional[int] = np.asarray(intermediate_weights[4][1] ) set_param( torch_block.feed_forward.output.dense , torch.tensor(SCREAMING_SNAKE_CASE__ ).transpose(0 , 1 ).contiguous() , torch.tensor(SCREAMING_SNAKE_CASE__ ) , ) def _UpperCamelCase ( lowercase__ , lowercase__ , lowercase__ ): # reformer model __SCREAMING_SNAKE_CASE : Any = torch_model.reformer # word embeds __SCREAMING_SNAKE_CASE : List[str] = np.asarray(weights[1] ) set_param( torch_model_reformer.embeddings.word_embeddings , torch.tensor(SCREAMING_SNAKE_CASE__ ) , ) if isinstance(weights[3] , SCREAMING_SNAKE_CASE__ ): __SCREAMING_SNAKE_CASE : Union[str, Any] = torch_model_reformer.embeddings.position_embeddings for emb_idx in range(len(position_embeddings.weights ) ): __SCREAMING_SNAKE_CASE : Any = np.asarray(weights[3][emb_idx][0] ) assert ( position_embeddings.weights[emb_idx].shape == emb_weights.shape ), F'''{position_embeddings[emb_idx]} emb does not match''' __SCREAMING_SNAKE_CASE : List[Any] = nn.Parameter(torch.tensor(SCREAMING_SNAKE_CASE__ ) ) __SCREAMING_SNAKE_CASE : str = weights[5] assert len(torch_model_reformer.encoder.layers ) * 4 == len( SCREAMING_SNAKE_CASE__ ), "HF and trax model do not have the same number of layers" for layer_idx, layer in enumerate(torch_model_reformer.encoder.layers ): __SCREAMING_SNAKE_CASE : List[Any] = trax_layer_weights[4 * layer_idx : 4 * (layer_idx + 1)] set_block_weights_in_torch(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) # output layer norm __SCREAMING_SNAKE_CASE : Union[str, Any] = np.asarray(weights[7][0] ) __SCREAMING_SNAKE_CASE : Union[str, Any] = np.asarray(weights[7][1] ) set_param( torch_model_reformer.encoder.layer_norm , torch.tensor(SCREAMING_SNAKE_CASE__ ) , torch.tensor(SCREAMING_SNAKE_CASE__ ) , ) # output embeddings __SCREAMING_SNAKE_CASE : Optional[int] = np.asarray(weights[9][0] ) __SCREAMING_SNAKE_CASE : str = np.asarray(weights[9][1] ) set_param( torch_model.lm_head.decoder , torch.tensor(SCREAMING_SNAKE_CASE__ ).transpose(0 , 1 ).contiguous() , torch.tensor(SCREAMING_SNAKE_CASE__ ) , ) def _UpperCamelCase ( lowercase__ , lowercase__ , lowercase__ ): # Initialise PyTorch model __SCREAMING_SNAKE_CASE : Union[str, Any] = ReformerConfig.from_json_file(SCREAMING_SNAKE_CASE__ ) print(F'''Building PyTorch model from configuration: {config}''' ) __SCREAMING_SNAKE_CASE : int = ReformerModelWithLMHead(SCREAMING_SNAKE_CASE__ ) with open(SCREAMING_SNAKE_CASE__ , '''rb''' ) as f: __SCREAMING_SNAKE_CASE : Optional[int] = pickle.load(SCREAMING_SNAKE_CASE__ )['''weights'''] set_model_weights_in_torch(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , config.hidden_size ) # Save pytorch-model print(F'''Save PyTorch model to {pytorch_dump_path}''' ) torch.save(model.state_dict() , SCREAMING_SNAKE_CASE__ ) if __name__ == "__main__": __lowerCAmelCase : List[Any] =argparse.ArgumentParser() # Required parameters parser.add_argument( '--trax_model_pkl_path', default=None, type=str, required=True, help='Path to the TensorFlow checkpoint path.' ) parser.add_argument( '--config_file', default=None, type=str, required=True, help=( 'The config json file corresponding to the pre-trained Reformer model. \n' 'This specifies the model architecture.' ), ) parser.add_argument( '--pytorch_dump_path', default=None, type=str, required=True, help='Path to the output PyTorch model.' ) __lowerCAmelCase : List[Any] =parser.parse_args() convert_trax_checkpoint_to_pytorch(args.trax_model_pkl_path, args.config_file, args.pytorch_dump_path)
9
from __future__ import annotations from typing import Any def _A ( SCREAMING_SNAKE_CASE__ : list[Any] ): create_state_space_tree(SCREAMING_SNAKE_CASE__ , [] , 0 ) def _A ( SCREAMING_SNAKE_CASE__ : list[Any] , SCREAMING_SNAKE_CASE__ : list[Any] , SCREAMING_SNAKE_CASE__ : int ): if index == len(SCREAMING_SNAKE_CASE__ ): print(SCREAMING_SNAKE_CASE__ ) return create_state_space_tree(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , index + 1 ) current_subsequence.append(sequence[index] ) create_state_space_tree(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , index + 1 ) current_subsequence.pop() if __name__ == "__main__": __snake_case = [3, 1, 2, 4] generate_all_subsequences(seq) seq.clear() seq.extend(["""A""", """B""", """C"""]) generate_all_subsequences(seq)
259
0
from __future__ import annotations import math _lowerCAmelCase : int = '2020.9.26' _lowerCAmelCase : int = 'xcodz-dot, cclaus, dhruvmanila' def UpperCamelCase_( _snake_case : Tuple , _snake_case : int , _snake_case : Optional[int] , _snake_case : int , _snake_case : str ): """simple docstring""" if not all(isinstance(__snake_case , (float, int) ) for val in locals().values() ): __a =F'Input values must either be float or int: {list(locals().values() )}' raise TypeError(__snake_case ) __a =((x * distance) / (z + distance)) * scale __a =((y * distance) / (z + distance)) * scale return projected_x, projected_y def UpperCamelCase_( _snake_case : Optional[Any] , _snake_case : Any , _snake_case : str , _snake_case : Tuple , _snake_case : str ): """simple docstring""" if not isinstance(__snake_case , __snake_case ): raise TypeError('Axis must be a str' ) __a =locals() del input_variables["axis"] if not all(isinstance(__snake_case , (float, int) ) for val in input_variables.values() ): __a =( "Input values except axis must either be float or int: " F'{list(input_variables.values() )}' ) raise TypeError(__snake_case ) __a =(angle % 360) / 450 * 180 / math.pi if axis == "z": __a =x * math.cos(__snake_case ) - y * math.sin(__snake_case ) __a =y * math.cos(__snake_case ) + x * math.sin(__snake_case ) __a =z elif axis == "x": __a =y * math.cos(__snake_case ) - z * math.sin(__snake_case ) __a =z * math.cos(__snake_case ) + y * math.sin(__snake_case ) __a =x elif axis == "y": __a =x * math.cos(__snake_case ) - z * math.sin(__snake_case ) __a =z * math.cos(__snake_case ) + x * math.sin(__snake_case ) __a =y else: raise ValueError('not a valid axis, choose one of \'x\', \'y\', \'z\'' ) return new_x, new_y, new_z if __name__ == "__main__": import doctest doctest.testmod() print(f'''{convert_to_ad(1.0, 2.0, 3.0, 10.0, 10.0) = }''') print(f'''{rotate(1.0, 2.0, 3.0, "y", 90.0) = }''')
364
import argparse import torch from datasets import load_dataset from donut import DonutModel from transformers import ( DonutImageProcessor, DonutProcessor, DonutSwinConfig, DonutSwinModel, MBartConfig, MBartForCausalLM, VisionEncoderDecoderModel, XLMRobertaTokenizerFast, ) def UpperCamelCase_( _snake_case : Optional[Any] ): """simple docstring""" __a =model.config __a =DonutSwinConfig( image_size=original_config.input_size , patch_size=4 , depths=original_config.encoder_layer , num_heads=[4, 8, 16, 32] , window_size=original_config.window_size , embed_dim=128 , ) __a =MBartConfig( is_decoder=_snake_case , is_encoder_decoder=_snake_case , add_cross_attention=_snake_case , decoder_layers=original_config.decoder_layer , max_position_embeddings=original_config.max_position_embeddings , vocab_size=len( model.decoder.tokenizer ) , scale_embedding=_snake_case , add_final_layer_norm=_snake_case , ) return encoder_config, decoder_config def UpperCamelCase_( _snake_case : Tuple ): """simple docstring""" if "encoder.model" in name: __a =name.replace('encoder.model' , 'encoder' ) if "decoder.model" in name: __a =name.replace('decoder.model' , 'decoder' ) if "patch_embed.proj" in name: __a =name.replace('patch_embed.proj' , 'embeddings.patch_embeddings.projection' ) if "patch_embed.norm" in name: __a =name.replace('patch_embed.norm' , 'embeddings.norm' ) if name.startswith('encoder' ): if "layers" in name: __a ='encoder.' + name if "attn.proj" in name: __a =name.replace('attn.proj' , 'attention.output.dense' ) if "attn" in name and "mask" not in name: __a =name.replace('attn' , 'attention.self' ) if "norm1" in name: __a =name.replace('norm1' , 'layernorm_before' ) if "norm2" in name: __a =name.replace('norm2' , 'layernorm_after' ) if "mlp.fc1" in name: __a =name.replace('mlp.fc1' , 'intermediate.dense' ) if "mlp.fc2" in name: __a =name.replace('mlp.fc2' , 'output.dense' ) if name == "encoder.norm.weight": __a ='encoder.layernorm.weight' if name == "encoder.norm.bias": __a ='encoder.layernorm.bias' return name def UpperCamelCase_( _snake_case : Tuple , _snake_case : str ): """simple docstring""" for key in orig_state_dict.copy().keys(): __a =orig_state_dict.pop(_snake_case ) if "qkv" in key: __a =key.split('.' ) __a =int(key_split[3] ) __a =int(key_split[5] ) __a =model.encoder.encoder.layers[layer_num].blocks[block_num].attention.self.all_head_size if "weight" in key: __a =val[:dim, :] __a =val[dim : dim * 2, :] __a =val[-dim:, :] else: __a =val[:dim] __a =val[dim : dim * 2] __a =val[-dim:] elif "attn_mask" in key or key in ["encoder.model.norm.weight", "encoder.model.norm.bias"]: # HuggingFace implementation doesn't use attn_mask buffer # and model doesn't use final LayerNorms for the encoder pass else: __a =val return orig_state_dict def UpperCamelCase_( _snake_case : Tuple , _snake_case : Union[str, Any]=None , _snake_case : List[Any]=False ): """simple docstring""" __a =DonutModel.from_pretrained(_snake_case ).eval() # load HuggingFace model __a , __a =get_configs(_snake_case ) __a =DonutSwinModel(_snake_case ) __a =MBartForCausalLM(_snake_case ) __a =VisionEncoderDecoderModel(encoder=_snake_case , decoder=_snake_case ) model.eval() __a =original_model.state_dict() __a =convert_state_dict(_snake_case , _snake_case ) model.load_state_dict(_snake_case ) # verify results on scanned document __a =load_dataset('hf-internal-testing/example-documents' ) __a =dataset['test'][0]['image'].convert('RGB' ) __a =XLMRobertaTokenizerFast.from_pretrained(_snake_case , from_slow=_snake_case ) __a =DonutImageProcessor( do_align_long_axis=original_model.config.align_long_axis , size=original_model.config.input_size[::-1] ) __a =DonutProcessor(_snake_case , _snake_case ) __a =processor(_snake_case , return_tensors='pt' ).pixel_values if model_name == "naver-clova-ix/donut-base-finetuned-docvqa": __a ='<s_docvqa><s_question>{user_input}</s_question><s_answer>' __a ='When is the coffee break?' __a =task_prompt.replace('{user_input}' , _snake_case ) elif model_name == "naver-clova-ix/donut-base-finetuned-rvlcdip": __a ='<s_rvlcdip>' elif model_name in [ "naver-clova-ix/donut-base-finetuned-cord-v1", "naver-clova-ix/donut-base-finetuned-cord-v1-2560", ]: __a ='<s_cord>' elif model_name == "naver-clova-ix/donut-base-finetuned-cord-v2": __a ='s_cord-v2>' elif model_name == "naver-clova-ix/donut-base-finetuned-zhtrainticket": __a ='<s_zhtrainticket>' elif model_name in ["naver-clova-ix/donut-proto", "naver-clova-ix/donut-base"]: # use a random prompt __a ='hello world' else: raise ValueError('Model name not supported' ) __a =original_model.decoder.tokenizer(_snake_case , add_special_tokens=_snake_case , return_tensors='pt' )[ 'input_ids' ] __a =original_model.encoder.model.patch_embed(_snake_case ) __a , __a =model.encoder.embeddings(_snake_case ) assert torch.allclose(_snake_case , _snake_case , atol=1e-3 ) # verify encoder hidden states __a =original_model.encoder(_snake_case ) __a =model.encoder(_snake_case ).last_hidden_state assert torch.allclose(_snake_case , _snake_case , atol=1e-2 ) # verify decoder hidden states __a =original_model(_snake_case , _snake_case , _snake_case ).logits __a =model(_snake_case , decoder_input_ids=_snake_case ).logits assert torch.allclose(_snake_case , _snake_case , atol=1e-3 ) print('Looks ok!' ) if pytorch_dump_folder_path is not None: print(F'Saving model and processor to {pytorch_dump_folder_path}' ) model.save_pretrained(_snake_case ) processor.save_pretrained(_snake_case ) if push_to_hub: model.push_to_hub('nielsr/' + model_name.split('/' )[-1] , commit_message='Update model' ) processor.push_to_hub('nielsr/' + model_name.split('/' )[-1] , commit_message='Update model' ) if __name__ == "__main__": _lowerCAmelCase : List[str] = argparse.ArgumentParser() # Required parameters parser.add_argument( "--model_name", default="naver-clova-ix/donut-base-finetuned-docvqa", required=False, type=str, help="Name of the original model you'd like to convert.", ) parser.add_argument( "--pytorch_dump_folder_path", default=None, required=False, type=str, help="Path to the output PyTorch model directory.", ) parser.add_argument( "--push_to_hub", action="store_true", help="Whether or not to push the converted model and processor to the 🤗 hub.", ) _lowerCAmelCase : List[Any] = parser.parse_args() convert_donut_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
308
0
"""simple docstring""" import collections import importlib.util import os import re from pathlib import Path UpperCAmelCase__ = 'src/transformers' # Matches is_xxx_available() UpperCAmelCase__ = re.compile(r'is\_([a-z_]*)_available()') # Catches a one-line _import_struct = {xxx} UpperCAmelCase__ = re.compile(r'^_import_structure\s+=\s+\{([^\}]+)\}') # Catches a line with a key-values pattern: "bla": ["foo", "bar"] UpperCAmelCase__ = re.compile(r'\s+"\S*":\s+\[([^\]]*)\]') # Catches a line if not is_foo_available UpperCAmelCase__ = re.compile(r'^\s*if\s+not\s+is\_[a-z_]*\_available\(\)') # Catches a line _import_struct["bla"].append("foo") UpperCAmelCase__ = re.compile(r'^\s*_import_structure\["\S*"\]\.append\("(\S*)"\)') # Catches a line _import_struct["bla"].extend(["foo", "bar"]) or _import_struct["bla"] = ["foo", "bar"] UpperCAmelCase__ = re.compile(r'^\s*_import_structure\[\S*\](?:\.extend\(|\s*=\s+)\[([^\]]*)\]') # Catches a line with an object between quotes and a comma: "MyModel", UpperCAmelCase__ = re.compile('^\s+"([^"]+)",') # Catches a line with objects between brackets only: ["foo", "bar"], UpperCAmelCase__ = re.compile('^\s+\[([^\]]+)\]') # Catches a line with from foo import bar, bla, boo UpperCAmelCase__ = re.compile(r'\s+from\s+\S*\s+import\s+([^\(\s].*)\n') # Catches a line with try: UpperCAmelCase__ = re.compile(r'^\s*try:') # Catches a line with else: UpperCAmelCase__ = re.compile(r'^\s*else:') def _UpperCAmelCase ( __lowerCamelCase : Dict ) -> Any: if _re_test_backend.search(__lowerCamelCase ) is None: return None _snake_case = [b[0] for b in _re_backend.findall(__lowerCamelCase )] backends.sort() return "_and_".join(__lowerCamelCase ) def _UpperCAmelCase ( __lowerCamelCase : List[Any] ) -> Optional[Any]: with open(__lowerCamelCase , '''r''' , encoding='''utf-8''' , newline='''\n''' ) as f: _snake_case = f.readlines() _snake_case = 0 while line_index < len(__lowerCamelCase ) and not lines[line_index].startswith('''_import_structure = {''' ): line_index += 1 # If this is a traditional init, just return. if line_index >= len(__lowerCamelCase ): return None # First grab the objects without a specific backend in _import_structure _snake_case = [] while not lines[line_index].startswith('''if TYPE_CHECKING''' ) and find_backend(lines[line_index] ) is None: _snake_case = lines[line_index] # If we have everything on a single line, let's deal with it. if _re_one_line_import_struct.search(__lowerCamelCase ): _snake_case = _re_one_line_import_struct.search(__lowerCamelCase ).groups()[0] _snake_case = re.findall('''\[([^\]]+)\]''' , __lowerCamelCase ) for imp in imports: objects.extend([obj[1:-1] for obj in imp.split(''', ''' )] ) line_index += 1 continue _snake_case = _re_import_struct_key_value.search(__lowerCamelCase ) if single_line_import_search is not None: _snake_case = [obj[1:-1] for obj in single_line_import_search.groups()[0].split(''', ''' ) if len(__lowerCamelCase ) > 0] objects.extend(__lowerCamelCase ) elif line.startswith(''' ''' * 8 + '''"''' ): objects.append(line[9:-3] ) line_index += 1 _snake_case = {'''none''': objects} # Let's continue with backend-specific objects in _import_structure while not lines[line_index].startswith('''if TYPE_CHECKING''' ): # If the line is an if not is_backend_available, we grab all objects associated. _snake_case = find_backend(lines[line_index] ) # Check if the backend declaration is inside a try block: if _re_try.search(lines[line_index - 1] ) is None: _snake_case = None if backend is not None: line_index += 1 # Scroll until we hit the else block of try-except-else while _re_else.search(lines[line_index] ) is None: line_index += 1 line_index += 1 _snake_case = [] # Until we unindent, add backend objects to the list while len(lines[line_index] ) <= 1 or lines[line_index].startswith(''' ''' * 4 ): _snake_case = lines[line_index] if _re_import_struct_add_one.search(__lowerCamelCase ) is not None: objects.append(_re_import_struct_add_one.search(__lowerCamelCase ).groups()[0] ) elif _re_import_struct_add_many.search(__lowerCamelCase ) is not None: _snake_case = _re_import_struct_add_many.search(__lowerCamelCase ).groups()[0].split(''', ''' ) _snake_case = [obj[1:-1] for obj in imports if len(__lowerCamelCase ) > 0] objects.extend(__lowerCamelCase ) elif _re_between_brackets.search(__lowerCamelCase ) is not None: _snake_case = _re_between_brackets.search(__lowerCamelCase ).groups()[0].split(''', ''' ) _snake_case = [obj[1:-1] for obj in imports if len(__lowerCamelCase ) > 0] objects.extend(__lowerCamelCase ) elif _re_quote_object.search(__lowerCamelCase ) is not None: objects.append(_re_quote_object.search(__lowerCamelCase ).groups()[0] ) elif line.startswith(''' ''' * 8 + '''"''' ): objects.append(line[9:-3] ) elif line.startswith(''' ''' * 12 + '''"''' ): objects.append(line[13:-3] ) line_index += 1 _snake_case = objects else: line_index += 1 # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend _snake_case = [] while ( line_index < len(__lowerCamelCase ) and find_backend(lines[line_index] ) is None and not lines[line_index].startswith('''else''' ) ): _snake_case = lines[line_index] _snake_case = _re_import.search(__lowerCamelCase ) if single_line_import_search is not None: objects.extend(single_line_import_search.groups()[0].split(''', ''' ) ) elif line.startswith(''' ''' * 8 ): objects.append(line[8:-2] ) line_index += 1 _snake_case = {'''none''': objects} # Let's continue with backend-specific objects while line_index < len(__lowerCamelCase ): # If the line is an if is_backend_available, we grab all objects associated. _snake_case = find_backend(lines[line_index] ) # Check if the backend declaration is inside a try block: if _re_try.search(lines[line_index - 1] ) is None: _snake_case = None if backend is not None: line_index += 1 # Scroll until we hit the else block of try-except-else while _re_else.search(lines[line_index] ) is None: line_index += 1 line_index += 1 _snake_case = [] # Until we unindent, add backend objects to the list while len(lines[line_index] ) <= 1 or lines[line_index].startswith(''' ''' * 8 ): _snake_case = lines[line_index] _snake_case = _re_import.search(__lowerCamelCase ) if single_line_import_search is not None: objects.extend(single_line_import_search.groups()[0].split(''', ''' ) ) elif line.startswith(''' ''' * 12 ): objects.append(line[12:-2] ) line_index += 1 _snake_case = objects else: line_index += 1 return import_dict_objects, type_hint_objects def _UpperCAmelCase ( __lowerCamelCase : Dict , __lowerCamelCase : Union[str, Any] ) -> Union[str, Any]: def find_duplicates(__lowerCamelCase : Dict ): return [k for k, v in collections.Counter(__lowerCamelCase ).items() if v > 1] if list(import_dict_objects.keys() ) != list(type_hint_objects.keys() ): return ["Both sides of the init do not have the same backends!"] _snake_case = [] for key in import_dict_objects.keys(): _snake_case = find_duplicates(import_dict_objects[key] ) if duplicate_imports: errors.append(f'''Duplicate _import_structure definitions for: {duplicate_imports}''' ) _snake_case = find_duplicates(type_hint_objects[key] ) if duplicate_type_hints: errors.append(f'''Duplicate TYPE_CHECKING objects for: {duplicate_type_hints}''' ) if sorted(set(import_dict_objects[key] ) ) != sorted(set(type_hint_objects[key] ) ): _snake_case = '''base imports''' if key == '''none''' else f'''{key} backend''' errors.append(f'''Differences for {name}:''' ) for a in type_hint_objects[key]: if a not in import_dict_objects[key]: errors.append(f''' {a} in TYPE_HINT but not in _import_structure.''' ) for a in import_dict_objects[key]: if a not in type_hint_objects[key]: errors.append(f''' {a} in _import_structure but not in TYPE_HINT.''' ) return errors def _UpperCAmelCase ( ) -> List[Any]: _snake_case = [] for root, _, files in os.walk(__lowerCamelCase ): if "__init__.py" in files: _snake_case = os.path.join(__lowerCamelCase , '''__init__.py''' ) _snake_case = parse_init(__lowerCamelCase ) if objects is not None: _snake_case = analyze_results(*__lowerCamelCase ) if len(__lowerCamelCase ) > 0: _snake_case = f'''Problem in {fname}, both halves do not define the same objects.\n{errors[0]}''' failures.append('''\n'''.join(__lowerCamelCase ) ) if len(__lowerCamelCase ) > 0: raise ValueError('''\n\n'''.join(__lowerCamelCase ) ) def _UpperCAmelCase ( ) -> Dict: _snake_case = [] for path, directories, files in os.walk(__lowerCamelCase ): for folder in directories: # Ignore private modules if folder.startswith('''_''' ): directories.remove(__lowerCamelCase ) continue # Ignore leftovers from branches (empty folders apart from pycache) if len(list((Path(__lowerCamelCase ) / folder).glob('''*.py''' ) ) ) == 0: continue _snake_case = str((Path(__lowerCamelCase ) / folder).relative_to(__lowerCamelCase ) ) _snake_case = short_path.replace(os.path.sep , '''.''' ) submodules.append(__lowerCamelCase ) for fname in files: if fname == "__init__.py": continue _snake_case = str((Path(__lowerCamelCase ) / fname).relative_to(__lowerCamelCase ) ) _snake_case = short_path.replace('''.py''' , '''''' ).replace(os.path.sep , '''.''' ) if len(submodule.split('''.''' ) ) == 1: submodules.append(__lowerCamelCase ) return submodules UpperCAmelCase__ = [ 'convert_pytorch_checkpoint_to_tf2', 'modeling_flax_pytorch_utils', ] def _UpperCAmelCase ( ) -> List[Any]: # This is to make sure the transformers module imported is the one in the repo. _snake_case = importlib.util.spec_from_file_location( '''transformers''' , os.path.join(__lowerCamelCase , '''__init__.py''' ) , submodule_search_locations=[PATH_TO_TRANSFORMERS] , ) _snake_case = spec.loader.load_module() _snake_case = [ module for module in get_transformers_submodules() if module not in IGNORE_SUBMODULES and module not in transformers._import_structure.keys() ] if len(__lowerCamelCase ) > 0: _snake_case = '''\n'''.join(f'''- {module}''' for module in module_not_registered ) raise ValueError( '''The following submodules are not properly registered in the main init of Transformers:\n''' f'''{list_of_modules}\n''' '''Make sure they appear somewhere in the keys of `_import_structure` with an empty list as value.''' ) if __name__ == "__main__": check_all_inits() check_submodules()
288
"""simple docstring""" import os import posixpath import uuid from dataclasses import dataclass from typing import TYPE_CHECKING, Iterable, List, Optional, Tuple, Union import numpy as np import pyarrow as pa import datasets from datasets.arrow_writer import ArrowWriter, ParquetWriter from datasets.config import MAX_SHARD_SIZE from datasets.filesystems import ( is_remote_filesystem, rename, ) from datasets.iterable_dataset import _BaseExamplesIterable from datasets.utils.py_utils import convert_file_size_to_int UpperCAmelCase__ = datasets.utils.logging.get_logger(__name__) if TYPE_CHECKING: import pyspark @dataclass class lowerCAmelCase__ ( datasets.BuilderConfig ): __a = None def _UpperCAmelCase ( __lowerCamelCase : "pyspark.sql.DataFrame" , __lowerCamelCase : List[int] , ) -> Optional[int]: import pyspark def generate_fn(): _snake_case = df.select('''*''' , pyspark.sql.functions.spark_partition_id().alias('''part_id''' ) ) for partition_id in partition_order: _snake_case = df_with_partition_id.select('''*''' ).where(f'''part_id = {partition_id}''' ).drop('''part_id''' ) _snake_case = partition_df.collect() _snake_case = 0 for row in rows: yield f'''{partition_id}_{row_id}''', row.asDict() row_id += 1 return generate_fn class lowerCAmelCase__ ( _BaseExamplesIterable ): def __init__( self : Optional[int] , _lowerCamelCase : "pyspark.sql.DataFrame" , _lowerCamelCase : List[Any]=None , ): _snake_case = df _snake_case = partition_order or range(self.df.rdd.getNumPartitions() ) _snake_case = _generate_iterable_examples(self.df , self.partition_order ) def __iter__( self : Optional[int] ): yield from self.generate_examples_fn() def lowercase ( self : Any , _lowerCamelCase : np.random.Generator ): _snake_case = list(range(self.df.rdd.getNumPartitions() ) ) generator.shuffle(_lowerCamelCase ) return SparkExamplesIterable(self.df , partition_order=_lowerCamelCase ) def lowercase ( self : List[Any] , _lowerCamelCase : int , _lowerCamelCase : int ): _snake_case = self.split_shard_indices_by_worker(_lowerCamelCase , _lowerCamelCase ) return SparkExamplesIterable(self.df , partition_order=_lowerCamelCase ) @property def lowercase ( self : List[str] ): return len(self.partition_order ) class lowerCAmelCase__ ( datasets.DatasetBuilder ): __a = SparkConfig def __init__( self : str , _lowerCamelCase : "pyspark.sql.DataFrame" , _lowerCamelCase : str = None , _lowerCamelCase : str = None , **_lowerCamelCase : List[str] , ): import pyspark _snake_case = pyspark.sql.SparkSession.builder.getOrCreate() _snake_case = df _snake_case = working_dir super().__init__( cache_dir=_lowerCamelCase , config_name=str(self.df.semanticHash() ) , **_lowerCamelCase , ) def lowercase ( self : str ): # Returns the path of the created file. def create_cache_and_write_probe(_lowerCamelCase : List[str] ): # makedirs with exist_ok will recursively create the directory. It will not throw an error if directories # already exist. os.makedirs(self._cache_dir , exist_ok=_lowerCamelCase ) _snake_case = os.path.join(self._cache_dir , '''fs_test''' + uuid.uuida().hex ) # Opening the file in append mode will create a new file unless it already exists, in which case it will not # change the file contents. open(_lowerCamelCase , '''a''' ) return [probe_file] if self._spark.conf.get('''spark.master''' , '''''' ).startswith('''local''' ): return # If the cluster is multi-node, make sure that the user provided a cache_dir and that it is on an NFS # accessible to the driver. # TODO: Stream batches to the driver using ArrowCollectSerializer instead of throwing an error. if self._cache_dir: _snake_case = ( self._spark.sparkContext.parallelize(range(1 ) , 1 ).mapPartitions(_lowerCamelCase ).collect() ) if os.path.isfile(probe[0] ): return raise ValueError( '''When using Dataset.from_spark on a multi-node cluster, the driver and all workers should be able to access cache_dir''' ) def lowercase ( self : Dict ): return datasets.DatasetInfo(features=self.config.features ) def lowercase ( self : Union[str, Any] , _lowerCamelCase : datasets.download.download_manager.DownloadManager ): return [datasets.SplitGenerator(name=datasets.Split.TRAIN )] def lowercase ( self : Dict , _lowerCamelCase : List[Any] ): import pyspark def get_arrow_batch_size(_lowerCamelCase : List[Any] ): for batch in it: yield pa.RecordBatch.from_pydict({'''batch_bytes''': [batch.nbytes]} ) _snake_case = self.df.count() _snake_case = df_num_rows if df_num_rows <= 100 else 100 # Approximate the size of each row (in Arrow format) by averaging over a max-100-row sample. _snake_case = ( self.df.limit(_lowerCamelCase ) .repartition(1 ) .mapInArrow(_lowerCamelCase , '''batch_bytes: long''' ) .agg(pyspark.sql.functions.sum('''batch_bytes''' ).alias('''sample_bytes''' ) ) .collect()[0] .sample_bytes / sample_num_rows ) _snake_case = approx_bytes_per_row * df_num_rows if approx_total_size > max_shard_size: # Make sure there is at least one row per partition. _snake_case = min(_lowerCamelCase , int(approx_total_size / max_shard_size ) ) _snake_case = self.df.repartition(_lowerCamelCase ) def lowercase ( self : Dict , _lowerCamelCase : str , _lowerCamelCase : str , _lowerCamelCase : int , ): import pyspark _snake_case = ParquetWriter if file_format == '''parquet''' else ArrowWriter _snake_case = os.path.join(self._working_dir , os.path.basename(_lowerCamelCase ) ) if self._working_dir else fpath _snake_case = file_format == '''parquet''' # Define these so that we don't reference self in write_arrow, which will result in a pickling error due to # pickling the SparkContext. _snake_case = self.config.features _snake_case = self._writer_batch_size _snake_case = self._fs.storage_options def write_arrow(_lowerCamelCase : Tuple ): # Within the same SparkContext, no two task attempts will share the same attempt ID. _snake_case = pyspark.TaskContext().taskAttemptId() _snake_case = next(_lowerCamelCase , _lowerCamelCase ) if first_batch is None: # Some partitions might not receive any data. return pa.RecordBatch.from_arrays( [[task_id], [0], [0]] , names=['''task_id''', '''num_examples''', '''num_bytes'''] , ) _snake_case = 0 _snake_case = writer_class( features=_lowerCamelCase , path=working_fpath.replace('''SSSSS''' , f'''{shard_id:05d}''' ).replace('''TTTTT''' , f'''{task_id:05d}''' ) , writer_batch_size=_lowerCamelCase , storage_options=_lowerCamelCase , embed_local_files=_lowerCamelCase , ) _snake_case = pa.Table.from_batches([first_batch] ) writer.write_table(_lowerCamelCase ) for batch in it: if max_shard_size is not None and writer._num_bytes >= max_shard_size: _snake_case , _snake_case = writer.finalize() writer.close() yield pa.RecordBatch.from_arrays( [[task_id], [num_examples], [num_bytes]] , names=['''task_id''', '''num_examples''', '''num_bytes'''] , ) shard_id += 1 _snake_case = writer_class( features=writer._features , path=working_fpath.replace('''SSSSS''' , f'''{shard_id:05d}''' ).replace('''TTTTT''' , f'''{task_id:05d}''' ) , writer_batch_size=_lowerCamelCase , storage_options=_lowerCamelCase , embed_local_files=_lowerCamelCase , ) _snake_case = pa.Table.from_batches([batch] ) writer.write_table(_lowerCamelCase ) if writer._num_bytes > 0: _snake_case , _snake_case = writer.finalize() writer.close() yield pa.RecordBatch.from_arrays( [[task_id], [num_examples], [num_bytes]] , names=['''task_id''', '''num_examples''', '''num_bytes'''] , ) if working_fpath != fpath: for file in os.listdir(os.path.dirname(_lowerCamelCase ) ): _snake_case = os.path.join(os.path.dirname(_lowerCamelCase ) , os.path.basename(_lowerCamelCase ) ) shutil.move(_lowerCamelCase , _lowerCamelCase ) _snake_case = ( self.df.mapInArrow(_lowerCamelCase , '''task_id: long, num_examples: long, num_bytes: long''' ) .groupBy('''task_id''' ) .agg( pyspark.sql.functions.sum('''num_examples''' ).alias('''total_num_examples''' ) , pyspark.sql.functions.sum('''num_bytes''' ).alias('''total_num_bytes''' ) , pyspark.sql.functions.count('''num_bytes''' ).alias('''num_shards''' ) , pyspark.sql.functions.collect_list('''num_examples''' ).alias('''shard_lengths''' ) , ) .collect() ) for row in stats: yield row.task_id, (row.total_num_examples, row.total_num_bytes, row.num_shards, row.shard_lengths) def lowercase ( self : int , _lowerCamelCase : "datasets.SplitGenerator" , _lowerCamelCase : str = "arrow" , _lowerCamelCase : Optional[Union[str, int]] = None , _lowerCamelCase : Optional[int] = None , **_lowerCamelCase : List[Any] , ): self._validate_cache_dir() _snake_case = convert_file_size_to_int(max_shard_size or MAX_SHARD_SIZE ) self._repartition_df_if_needed(_lowerCamelCase ) _snake_case = not is_remote_filesystem(self._fs ) _snake_case = os.path.join if is_local else posixpath.join _snake_case = '''-TTTTT-SSSSS-of-NNNNN''' _snake_case = f'''{self.name}-{split_generator.name}{SUFFIX}.{file_format}''' _snake_case = path_join(self._output_dir , _lowerCamelCase ) _snake_case = 0 _snake_case = 0 _snake_case = 0 _snake_case = [] _snake_case = [] for task_id, content in self._prepare_split_single(_lowerCamelCase , _lowerCamelCase , _lowerCamelCase ): ( ( _snake_case ) , ( _snake_case ) , ( _snake_case ) , ( _snake_case ) , ) = content if num_bytes > 0: total_num_examples += num_examples total_num_bytes += num_bytes total_shards += num_shards task_id_and_num_shards.append((task_id, num_shards) ) all_shard_lengths.extend(_lowerCamelCase ) _snake_case = total_num_examples _snake_case = total_num_bytes # should rename everything at the end logger.debug(f'''Renaming {total_shards} shards.''' ) if total_shards > 1: _snake_case = all_shard_lengths # Define fs outside of _rename_shard so that we don't reference self in the function, which will result in a # pickling error due to pickling the SparkContext. _snake_case = self._fs # use the -SSSSS-of-NNNNN pattern def _rename_shard( _lowerCamelCase : int , _lowerCamelCase : int , _lowerCamelCase : int , ): rename( _lowerCamelCase , fpath.replace('''SSSSS''' , f'''{shard_id:05d}''' ).replace('''TTTTT''' , f'''{task_id:05d}''' ) , fpath.replace('''TTTTT-SSSSS''' , f'''{global_shard_id:05d}''' ).replace('''NNNNN''' , f'''{total_shards:05d}''' ) , ) _snake_case = [] _snake_case = 0 for i in range(len(_lowerCamelCase ) ): _snake_case , _snake_case = task_id_and_num_shards[i] for shard_id in range(_lowerCamelCase ): args.append([task_id, shard_id, global_shard_id] ) global_shard_id += 1 self._spark.sparkContext.parallelize(_lowerCamelCase , len(_lowerCamelCase ) ).map(lambda _lowerCamelCase : _rename_shard(*_lowerCamelCase ) ).collect() else: # don't use any pattern _snake_case = 0 _snake_case = task_id_and_num_shards[0][0] self._rename( fpath.replace('''SSSSS''' , f'''{shard_id:05d}''' ).replace('''TTTTT''' , f'''{task_id:05d}''' ) , fpath.replace(_lowerCamelCase , '''''' ) , ) def lowercase ( self : List[str] , _lowerCamelCase : "datasets.SplitGenerator" , ): return SparkExamplesIterable(self.df )
288
1
from typing import List from ...configuration_utils import PretrainedConfig from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = { 'snap-research/efficientformer-l1-300': ( 'https://huggingface.co/snap-research/efficientformer-l1-300/resolve/main/config.json' ), } class A ( lowerCamelCase__ ): lowerCamelCase = 'efficientformer' def __init__( self : List[str],lowercase_ : List[int] = [3, 2, 6, 4],lowercase_ : List[int] = [4_8, 9_6, 2_2_4, 4_4_8],lowercase_ : List[bool] = [True, True, True, True],lowercase_ : int = 4_4_8,lowercase_ : int = 3_2,lowercase_ : int = 4,lowercase_ : int = 7,lowercase_ : int = 5,lowercase_ : int = 8,lowercase_ : int = 4,lowercase_ : float = 0.0,lowercase_ : int = 1_6,lowercase_ : int = 3,lowercase_ : int = 3,lowercase_ : int = 3,lowercase_ : int = 2,lowercase_ : int = 1,lowercase_ : float = 0.0,lowercase_ : int = 1,lowercase_ : bool = True,lowercase_ : bool = True,lowercase_ : float = 1E-5,lowercase_ : str = "gelu",lowercase_ : float = 0.02,lowercase_ : float = 1E-12,lowercase_ : int = 2_2_4,lowercase_ : float = 1E-05,**lowercase_ : List[Any],)-> List[Any]: '''simple docstring''' super().__init__(**__snake_case ) A__ = hidden_act A__ = hidden_dropout_prob A__ = hidden_sizes A__ = num_hidden_layers A__ = num_attention_heads A__ = initializer_range A__ = layer_norm_eps A__ = patch_size A__ = num_channels A__ = depths A__ = mlp_expansion_ratio A__ = downsamples A__ = dim A__ = key_dim A__ = attention_ratio A__ = resolution A__ = pool_size A__ = downsample_patch_size A__ = downsample_stride A__ = downsample_pad A__ = drop_path_rate A__ = num_metaad_blocks A__ = distillation A__ = use_layer_scale A__ = layer_scale_init_value A__ = image_size A__ = batch_norm_eps
358
import unittest from typing import Dict, List, Optional, Union 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, prepare_image_inputs if is_torch_available(): import torch if is_vision_available(): from PIL import Image from transformers import BridgeTowerImageProcessor class A ( unittest.TestCase ): """simple docstring""" def __init__( self : List[str],lowercase_ : List[str],lowercase_ : bool = True,lowercase_ : Dict[str, int] = None,lowercase_ : int = 3_2,lowercase_ : bool = True,lowercase_ : Union[int, float] = 1 / 2_5_5,lowercase_ : bool = True,lowercase_ : bool = True,lowercase_ : Optional[Union[float, List[float]]] = [0.48_145_466, 0.4_578_275, 0.40_821_073],lowercase_ : Optional[Union[float, List[float]]] = [0.26_862_954, 0.26_130_258, 0.27_577_711],lowercase_ : bool = True,lowercase_ : Tuple=7,lowercase_ : str=3_0,lowercase_ : Union[str, Any]=4_0_0,lowercase_ : Dict=3,)-> List[Any]: '''simple docstring''' A__ = parent A__ = do_resize A__ = size if size is not None else {'shortest_edge': 2_8_8} A__ = size_divisor A__ = do_rescale A__ = rescale_factor A__ = do_normalize A__ = do_center_crop A__ = image_mean A__ = image_std A__ = do_pad A__ = batch_size A__ = num_channels A__ = min_resolution A__ = max_resolution def snake_case__ ( self : Optional[Any] )-> Optional[int]: '''simple docstring''' return { "image_mean": self.image_mean, "image_std": self.image_std, "do_normalize": self.do_normalize, "do_resize": self.do_resize, "size": self.size, "size_divisor": self.size_divisor, } def snake_case__ ( self : int,lowercase_ : Optional[int],lowercase_ : List[str]=False )-> Any: '''simple docstring''' if not batched: A__ = self.size['shortest_edge'] A__ = image_inputs[0] if isinstance(lowercase_,Image.Image ): A__ , A__ = image.size else: A__ , A__ = image.shape[1], image.shape[2] A__ = size / min(lowercase_,lowercase_ ) if h < w: A__ , A__ = size, scale * w else: A__ , A__ = scale * h, size A__ = int((1_3_3_3 / 8_0_0) * size ) if max(lowercase_,lowercase_ ) > max_size: A__ = max_size / max(lowercase_,lowercase_ ) A__ = newh * scale A__ = neww * scale A__ , A__ = int(newh + 0.5 ), int(neww + 0.5 ) A__ , A__ = ( newh // self.size_divisor * self.size_divisor, neww // self.size_divisor * self.size_divisor, ) else: A__ = [] for image in image_inputs: A__ , A__ = self.get_expected_values([image] ) expected_values.append((expected_height, expected_width) ) A__ = max(lowercase_,key=lambda lowercase_ : item[0] )[0] A__ = max(lowercase_,key=lambda lowercase_ : item[1] )[1] return expected_height, expected_width @require_torch @require_vision class A ( _UpperCAmelCase , unittest.TestCase ): """simple docstring""" lowerCamelCase = BridgeTowerImageProcessor if is_vision_available() else None def snake_case__ ( self : str )-> Optional[int]: '''simple docstring''' A__ = BridgeTowerImageProcessingTester(self ) @property def snake_case__ ( self : Dict )-> List[str]: '''simple docstring''' return self.image_processor_tester.prepare_image_processor_dict() def snake_case__ ( self : Optional[Any] )-> Tuple: '''simple docstring''' A__ = self.image_processing_class(**self.image_processor_dict ) self.assertTrue(hasattr(lowercase_,'image_mean' ) ) self.assertTrue(hasattr(lowercase_,'image_std' ) ) self.assertTrue(hasattr(lowercase_,'do_normalize' ) ) self.assertTrue(hasattr(lowercase_,'do_resize' ) ) self.assertTrue(hasattr(lowercase_,'size' ) ) self.assertTrue(hasattr(lowercase_,'size_divisor' ) ) def snake_case__ ( self : Any )-> List[str]: '''simple docstring''' pass def snake_case__ ( self : int )-> Any: '''simple docstring''' A__ = self.image_processing_class(**self.image_processor_dict ) # create random PIL images A__ = prepare_image_inputs(self.image_processor_tester,equal_resolution=lowercase_ ) for image in image_inputs: self.assertIsInstance(lowercase_,Image.Image ) # Test not batched input A__ = image_processing(image_inputs[0],return_tensors='pt' ).pixel_values A__ , A__ = self.image_processor_tester.get_expected_values(lowercase_ ) self.assertEqual( encoded_images.shape,(1, self.image_processor_tester.num_channels, expected_height, expected_width),) # Test batched A__ = image_processing(lowercase_,return_tensors='pt' ).pixel_values A__ , A__ = self.image_processor_tester.get_expected_values(lowercase_,batched=lowercase_ ) self.assertEqual( encoded_images.shape,( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, expected_height, expected_width, ),) def snake_case__ ( self : List[str] )-> Tuple: '''simple docstring''' A__ = self.image_processing_class(**self.image_processor_dict ) # create random numpy tensors A__ = prepare_image_inputs(self.image_processor_tester,equal_resolution=lowercase_,numpify=lowercase_ ) for image in image_inputs: self.assertIsInstance(lowercase_,np.ndarray ) # Test not batched input A__ = image_processing(image_inputs[0],return_tensors='pt' ).pixel_values A__ , A__ = self.image_processor_tester.get_expected_values(lowercase_ ) self.assertEqual( encoded_images.shape,(1, self.image_processor_tester.num_channels, expected_height, expected_width),) # Test batched A__ = image_processing(lowercase_,return_tensors='pt' ).pixel_values A__ , A__ = self.image_processor_tester.get_expected_values(lowercase_,batched=lowercase_ ) self.assertEqual( encoded_images.shape,( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, expected_height, expected_width, ),) def snake_case__ ( self : Optional[Any] )-> List[Any]: '''simple docstring''' A__ = self.image_processing_class(**self.image_processor_dict ) # create random PyTorch tensors A__ = prepare_image_inputs(self.image_processor_tester,equal_resolution=lowercase_,torchify=lowercase_ ) for image in image_inputs: self.assertIsInstance(lowercase_,torch.Tensor ) # Test not batched input A__ = image_processing(image_inputs[0],return_tensors='pt' ).pixel_values A__ , A__ = self.image_processor_tester.get_expected_values(lowercase_ ) self.assertEqual( encoded_images.shape,(1, self.image_processor_tester.num_channels, expected_height, expected_width),) # Test batched A__ = image_processing(lowercase_,return_tensors='pt' ).pixel_values A__ , A__ = self.image_processor_tester.get_expected_values(lowercase_,batched=lowercase_ ) self.assertEqual( encoded_images.shape,( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, expected_height, expected_width, ),)
282
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 ): def __init__(self : Optional[Any] , __a : List[Any] , __a : Tuple=13 , __a : Any=7 , __a : List[Any]=True , __a : List[Any]=True , __a : Dict=True , __a : List[str]=True , __a : Dict=99 , __a : List[Any]=32 , __a : List[Any]=5 , __a : Union[str, Any]=4 , __a : Optional[int]=37 , __a : Optional[int]="gelu" , __a : Union[str, Any]=0.1 , __a : List[Any]=0.1 , __a : Tuple=512 , __a : Any=16 , __a : Tuple=2 , __a : List[str]=0.02 , __a : str=4 , ): 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 _lowercase (self : Optional[Any] ): 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_ = 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_=__a , ) return config, input_ids, attention_mask def _lowercase (self : Union[str, Any] ): UpperCAmelCase_ = self.prepare_config_and_inputs() UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ = config_and_inputs UpperCAmelCase_ = {"input_ids": input_ids, "attention_mask": attention_mask} return config, inputs_dict @require_flax class __A ( UpperCamelCase__ , unittest.TestCase ): a__ : List[str] = ( ( FlaxDistilBertModel, FlaxDistilBertForMaskedLM, FlaxDistilBertForMultipleChoice, FlaxDistilBertForQuestionAnswering, FlaxDistilBertForSequenceClassification, FlaxDistilBertForTokenClassification, FlaxDistilBertForQuestionAnswering, ) if is_flax_available() else () ) def _lowercase (self : str ): UpperCAmelCase_ = FlaxDistilBertModelTester(self ) @slow def _lowercase (self : int ): for model_class_name in self.all_model_classes: UpperCAmelCase_ = model_class_name.from_pretrained("distilbert-base-uncased" ) UpperCAmelCase_ = model(np.ones((1, 1) ) ) self.assertIsNotNone(__a ) @require_flax class __A ( unittest.TestCase ): @slow def _lowercase (self : Optional[int] ): UpperCAmelCase_ = FlaxDistilBertModel.from_pretrained("distilbert-base-uncased" ) UpperCAmelCase_ = np.array([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]] ) UpperCAmelCase_ = np.array([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] ) UpperCAmelCase_ = model(__a , attention_mask=__a )[0] UpperCAmelCase_ = (1, 11, 768) self.assertEqual(output.shape , __a ) UpperCAmelCase_ = np.array([[[-0.16_39, 0.32_99, 0.16_48], [-0.17_46, 0.32_89, 0.17_10], [-0.18_84, 0.33_57, 0.18_10]]] ) self.assertTrue(jnp.allclose(output[:, 1:4, 1:4] , __a , atol=1E-4 ) )
1
'''simple docstring''' from __future__ import annotations import queue class __A : def __init__(self : Optional[Any] , __a : str ): UpperCAmelCase_ = data UpperCAmelCase_ = None UpperCAmelCase_ = None def lowerCAmelCase_ ( ) -> TreeNode: '''simple docstring''' print("\n********Press N to stop entering at any point of time********\n" ) UpperCAmelCase_ = input("Enter the value of the root node: " ).strip().lower() UpperCAmelCase_ = queue.Queue() UpperCAmelCase_ = TreeNode(int(snake_case_ ) ) q.put(snake_case_ ) while not q.empty(): UpperCAmelCase_ = q.get() UpperCAmelCase_ = f"""Enter the left node of {node_found.data}: """ UpperCAmelCase_ = input(snake_case_ ).strip().lower() or "n" if check == "n": return tree_node UpperCAmelCase_ = TreeNode(int(snake_case_ ) ) UpperCAmelCase_ = left_node q.put(snake_case_ ) UpperCAmelCase_ = f"""Enter the right node of {node_found.data}: """ UpperCAmelCase_ = input(snake_case_ ).strip().lower() or "n" if check == "n": return tree_node UpperCAmelCase_ = TreeNode(int(snake_case_ ) ) UpperCAmelCase_ = right_node q.put(snake_case_ ) raise def lowerCAmelCase_ ( snake_case_ : TreeNode ) -> None: '''simple docstring''' if not isinstance(snake_case_ , snake_case_ ) or not node: return print(node.data , end="," ) pre_order(node.left ) pre_order(node.right ) def lowerCAmelCase_ ( snake_case_ : TreeNode ) -> None: '''simple docstring''' if not isinstance(snake_case_ , snake_case_ ) or not node: return in_order(node.left ) print(node.data , end="," ) in_order(node.right ) def lowerCAmelCase_ ( snake_case_ : TreeNode ) -> None: '''simple docstring''' if not isinstance(snake_case_ , snake_case_ ) or not node: return post_order(node.left ) post_order(node.right ) print(node.data , end="," ) def lowerCAmelCase_ ( snake_case_ : TreeNode ) -> None: '''simple docstring''' if not isinstance(snake_case_ , snake_case_ ) or not node: return UpperCAmelCase_ = queue.Queue() q.put(snake_case_ ) while not q.empty(): UpperCAmelCase_ = q.get() print(node_dequeued.data , end="," ) if node_dequeued.left: q.put(node_dequeued.left ) if node_dequeued.right: q.put(node_dequeued.right ) def lowerCAmelCase_ ( snake_case_ : TreeNode ) -> None: '''simple docstring''' if not isinstance(snake_case_ , snake_case_ ) or not node: return UpperCAmelCase_ = queue.Queue() q.put(snake_case_ ) while not q.empty(): UpperCAmelCase_ = [] while not q.empty(): UpperCAmelCase_ = q.get() print(node_dequeued.data , end="," ) if node_dequeued.left: list_.append(node_dequeued.left ) if node_dequeued.right: list_.append(node_dequeued.right ) print() for node in list_: q.put(snake_case_ ) def lowerCAmelCase_ ( snake_case_ : TreeNode ) -> None: '''simple docstring''' if not isinstance(snake_case_ , snake_case_ ) or not node: return UpperCAmelCase_ = [] UpperCAmelCase_ = node while n or stack: while n: # start from root node, find its left child print(n.data , end="," ) stack.append(snake_case_ ) UpperCAmelCase_ = n.left # end of while means current node doesn't have left child UpperCAmelCase_ = stack.pop() # start to traverse its right child UpperCAmelCase_ = n.right def lowerCAmelCase_ ( snake_case_ : TreeNode ) -> None: '''simple docstring''' if not isinstance(snake_case_ , snake_case_ ) or not node: return UpperCAmelCase_ = [] UpperCAmelCase_ = node while n or stack: while n: stack.append(snake_case_ ) UpperCAmelCase_ = n.left UpperCAmelCase_ = stack.pop() print(n.data , end="," ) UpperCAmelCase_ = n.right def lowerCAmelCase_ ( snake_case_ : TreeNode ) -> None: '''simple docstring''' if not isinstance(snake_case_ , snake_case_ ) or not node: return UpperCAmelCase_ , UpperCAmelCase_ = [], [] UpperCAmelCase_ = node stacka.append(snake_case_ ) while stacka: # to find the reversed order of post order, store it in stack2 UpperCAmelCase_ = stacka.pop() if n.left: stacka.append(n.left ) if n.right: stacka.append(n.right ) stacka.append(snake_case_ ) while stacka: # pop up from stack2 will be the post order print(stacka.pop().data , end="," ) def lowerCAmelCase_ ( snake_case_ : str = "" , snake_case_ : Any=50 , snake_case_ : Union[str, Any]="*" ) -> str: '''simple docstring''' if not s: return "\n" + width * char UpperCAmelCase_ , UpperCAmelCase_ = divmod(width - len(snake_case_ ) - 2 , 2 ) return f"""{left * char} {s} {(left + extra) * char}""" if __name__ == "__main__": import doctest doctest.testmod() print(prompt('Binary Tree Traversals')) SCREAMING_SNAKE_CASE_: TreeNode =build_tree() print(prompt('Pre Order Traversal')) pre_order(node) print(prompt() + '\n') print(prompt('In Order Traversal')) in_order(node) print(prompt() + '\n') print(prompt('Post Order Traversal')) post_order(node) print(prompt() + '\n') print(prompt('Level Order Traversal')) level_order(node) print(prompt() + '\n') print(prompt('Actual Level Order Traversal')) level_order_actual(node) print('*' * 50 + '\n') print(prompt('Pre Order Traversal - Iteration Version')) pre_order_iter(node) print(prompt() + '\n') print(prompt('In Order Traversal - Iteration Version')) in_order_iter(node) print(prompt() + '\n') print(prompt('Post Order Traversal - Iteration Version')) post_order_iter(node) print(prompt())
1
1
'''simple docstring''' def SCREAMING_SNAKE_CASE__( _UpperCamelCase : list ) -> float: '''simple docstring''' UpperCamelCase__ = 0 while len(_UpperCamelCase ) > 1: UpperCamelCase__ = 0 # Consider two files with minimum cost to be merged for _ in range(2 ): UpperCamelCase__ = files.index(min(_UpperCamelCase ) ) temp += files[min_index] files.pop(_UpperCamelCase ) files.append(_UpperCamelCase ) optimal_merge_cost += temp return optimal_merge_cost if __name__ == "__main__": import doctest doctest.testmod()
31
'''simple docstring''' from __future__ import annotations def SCREAMING_SNAKE_CASE__( _UpperCamelCase : list[int | str] ) -> None: '''simple docstring''' create_state_space_tree(_UpperCamelCase , [] , 0 , [0 for i in range(len(_UpperCamelCase ) )] ) def SCREAMING_SNAKE_CASE__( _UpperCamelCase : list[int | str] , _UpperCamelCase : list[int | str] , _UpperCamelCase : int , _UpperCamelCase : list[int] , ) -> None: '''simple docstring''' if index == len(_UpperCamelCase ): print(_UpperCamelCase ) return for i in range(len(_UpperCamelCase ) ): if not index_used[i]: current_sequence.append(sequence[i] ) UpperCamelCase__ = True create_state_space_tree(_UpperCamelCase , _UpperCamelCase , index + 1 , _UpperCamelCase ) current_sequence.pop() UpperCamelCase__ = False __lowercase: list[int | str] = [3, 1, 2, 4] generate_all_permutations(sequence) __lowercase: list[int | str] = ["A", "B", "C"] generate_all_permutations(sequence_a)
31
1
from typing import TYPE_CHECKING # rely on isort to merge the imports from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available lowercase : Tuple = { """configuration_autoformer""": [ """AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""", """AutoformerConfig""", ], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : Any = [ """AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""", """AutoformerForPrediction""", """AutoformerModel""", """AutoformerPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_autoformer import ( AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, AutoformerConfig, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_autoformer import ( AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, AutoformerForPrediction, AutoformerModel, AutoformerPreTrainedModel, ) else: import sys lowercase : Optional[Any] = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
20
"""simple docstring""" import inspect from typing import List, Optional, Tuple, Union import numpy as np import PIL import torch import torch.utils.checkpoint from ...models import UNetaDModel, VQModel from ...schedulers import ( DDIMScheduler, DPMSolverMultistepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, LMSDiscreteScheduler, PNDMScheduler, ) from ...utils import PIL_INTERPOLATION, randn_tensor from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput def _SCREAMING_SNAKE_CASE ( _lowercase : Union[str, Any] ) ->str: '''simple docstring''' a, a : str = image.size a, a : Tuple = (x - x % 32 for x in (w, h)) # resize to integer multiple of 32 a : Union[str, Any] = image.resize((w, h) , resample=PIL_INTERPOLATION["lanczos"] ) a : int = np.array(_lowercase ).astype(np.floataa ) / 255.0 a : List[str] = image[None].transpose(0 , 3 , 1 , 2 ) a : Dict = torch.from_numpy(_lowercase ) return 2.0 * image - 1.0 class __UpperCamelCase ( a__ ): def __init__( self , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , ) -> str: super().__init__() self.register_modules(vqvae=lowerCAmelCase__ , unet=lowerCAmelCase__ , scheduler=lowerCAmelCase__ ) @torch.no_grad() def __call__( self , lowerCAmelCase__ = None , lowerCAmelCase__ = 1 , lowerCAmelCase__ = 100 , lowerCAmelCase__ = 0.0 , lowerCAmelCase__ = None , lowerCAmelCase__ = "pil" , lowerCAmelCase__ = True , ) -> Union[Tuple, ImagePipelineOutput]: if isinstance(lowerCAmelCase__ , PIL.Image.Image ): a : int = 1 elif isinstance(lowerCAmelCase__ , torch.Tensor ): a : str = image.shape[0] else: raise ValueError(f"""`image` has to be of type `PIL.Image.Image` or `torch.Tensor` but is {type(lowerCAmelCase__ )}""" ) if isinstance(lowerCAmelCase__ , PIL.Image.Image ): a : Tuple = preprocess(lowerCAmelCase__ ) a, a : Optional[Any] = image.shape[-2:] # in_channels should be 6: 3 for latents, 3 for low resolution image a : Tuple = (batch_size, self.unet.config.in_channels // 2, height, width) a : List[str] = next(self.unet.parameters() ).dtype a : Any = randn_tensor(lowerCAmelCase__ , generator=lowerCAmelCase__ , device=self.device , dtype=lowerCAmelCase__ ) a : Union[str, Any] = image.to(device=self.device , dtype=lowerCAmelCase__ ) # set timesteps and move to the correct device self.scheduler.set_timesteps(lowerCAmelCase__ , device=self.device ) a : int = self.scheduler.timesteps # scale the initial noise by the standard deviation required by the scheduler a : str = latents * self.scheduler.init_noise_sigma # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature. # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502 # and should be between [0, 1] a : str = "eta" in set(inspect.signature(self.scheduler.step ).parameters.keys() ) a : List[Any] = {} if accepts_eta: a : Any = eta for t in self.progress_bar(lowerCAmelCase__ ): # concat latents and low resolution image in the channel dimension. a : str = torch.cat([latents, image] , dim=1 ) a : int = self.scheduler.scale_model_input(lowerCAmelCase__ , lowerCAmelCase__ ) # predict the noise residual a : Union[str, Any] = self.unet(lowerCAmelCase__ , lowerCAmelCase__ ).sample # compute the previous noisy sample x_t -> x_t-1 a : Tuple = self.scheduler.step(lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , **lowerCAmelCase__ ).prev_sample # decode the image latents with the VQVAE a : List[Any] = self.vqvae.decode(lowerCAmelCase__ ).sample a : int = torch.clamp(lowerCAmelCase__ , -1.0 , 1.0 ) a : Optional[int] = image / 2 + 0.5 a : Optional[int] = image.cpu().permute(0 , 2 , 3 , 1 ).numpy() if output_type == "pil": a : Union[str, Any] = self.numpy_to_pil(lowerCAmelCase__ ) if not return_dict: return (image,) return ImagePipelineOutput(images=lowerCAmelCase__ )
105
0
from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxSeqaSeqConfigWithPast from ...utils import logging snake_case_ : Any = logging.get_logger(__name__) snake_case_ : List[Any] = { "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 __snake_case ( a ): UpperCAmelCase__ : Optional[Any] = '''t5''' UpperCAmelCase__ : Optional[int] = ['''past_key_values'''] UpperCAmelCase__ : List[str] = {'''hidden_size''': '''d_model''', '''num_attention_heads''': '''num_heads''', '''num_hidden_layers''': '''num_layers'''} def __init__( self : Tuple , _snake_case : Optional[Any]=32128 , _snake_case : int=512 , _snake_case : Union[str, Any]=64 , _snake_case : List[str]=2048 , _snake_case : Tuple=6 , _snake_case : List[str]=None , _snake_case : List[Any]=8 , _snake_case : List[Any]=32 , _snake_case : Dict=128 , _snake_case : Tuple=0.1 , _snake_case : str=1e-6 , _snake_case : List[str]=1.0 , _snake_case : List[Any]="relu" , _snake_case : str=True , _snake_case : Optional[Any]=True , _snake_case : str=0 , _snake_case : int=1 , **_snake_case : 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(_snake_case) > 1 and act_info[0] != "gated" or len(_snake_case) > 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=_snake_case , eos_token_id=_snake_case , is_encoder_decoder=_snake_case , **_snake_case , ) class __snake_case ( a ): @property def lowerCamelCase ( self : 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_(_snake_case , direction='''inputs''') return common_inputs @property def lowerCamelCase ( self : Union[str, Any]): """simple docstring""" return 13
7
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 __snake_case ( a , unittest.TestCase ): UpperCAmelCase__ : Optional[Any] = FlaxAutoencoderKL @property def lowerCamelCase ( self : List[str]): """simple docstring""" UpperCAmelCase_ = 4 UpperCAmelCase_ = 3 UpperCAmelCase_ = (32, 32) UpperCAmelCase_ = jax.random.PRNGKey(0) UpperCAmelCase_ = jax.random.uniform(_snake_case , ((batch_size, num_channels) + sizes)) return {"sample": image, "prng_key": prng_key} def lowerCamelCase ( self : Optional[Any]): """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
7
1