code
stringlengths
87
55.2k
code_codestyle
int64
0
349
style_context
stringlengths
135
49.1k
style_context_codestyle
int64
0
349
label
int64
0
1
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available _lowercase : Any = { 'configuration_roc_bert': ['ROC_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'RoCBertConfig'], 'tokenization_roc_bert': ['RoCBertTokenizer'], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: pass try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : Dict = [ 'ROC_BERT_PRETRAINED_MODEL_ARCHIVE_LIST', 'RoCBertForCausalLM', 'RoCBertForMaskedLM', 'RoCBertForMultipleChoice', 'RoCBertForPreTraining', 'RoCBertForQuestionAnswering', 'RoCBertForSequenceClassification', 'RoCBertForTokenClassification', 'RoCBertLayer', 'RoCBertModel', 'RoCBertPreTrainedModel', 'load_tf_weights_in_roc_bert', ] if TYPE_CHECKING: from .configuration_roc_bert import ROC_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, RoCBertConfig from .tokenization_roc_bert import RoCBertTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: raise OptionalDependencyNotAvailable() try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_roc_bert import ( ROC_BERT_PRETRAINED_MODEL_ARCHIVE_LIST, RoCBertForCausalLM, RoCBertForMaskedLM, RoCBertForMultipleChoice, RoCBertForPreTraining, RoCBertForQuestionAnswering, RoCBertForSequenceClassification, RoCBertForTokenClassification, RoCBertLayer, RoCBertModel, RoCBertPreTrainedModel, load_tf_weights_in_roc_bert, ) else: import sys _lowercase : Tuple = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
332
"""simple docstring""" from __future__ import annotations class _UpperCAmelCase : def __init__( self : Tuple , _lowercase : str , _lowercase : str ): __UpperCAmelCase , __UpperCAmelCase = text, pattern __UpperCAmelCase , __UpperCAmelCase = len(_lowercase ), len(_lowercase ) def a ( self : Optional[int] , _lowercase : str ): for i in range(self.patLen - 1 , -1 , -1 ): if char == self.pattern[i]: return i return -1 def a ( self : int , _lowercase : int ): for i in range(self.patLen - 1 , -1 , -1 ): if self.pattern[i] != self.text[current_pos + i]: return current_pos + i return -1 def a ( self : Optional[Any] ): # searches pattern in text and returns index positions __UpperCAmelCase = [] for i in range(self.textLen - self.patLen + 1 ): __UpperCAmelCase = self.mismatch_in_text(_lowercase ) if mismatch_index == -1: positions.append(_lowercase ) else: __UpperCAmelCase = self.match_in_pattern(self.text[mismatch_index] ) __UpperCAmelCase = ( mismatch_index - match_index ) # shifting index lgtm [py/multiple-definition] return positions _lowercase : str = 'ABAABA' _lowercase : Tuple = 'AB' _lowercase : Dict = BoyerMooreSearch(text, pattern) _lowercase : Any = bms.bad_character_heuristic() if len(positions) == 0: print('No match found') else: print('Pattern found in following positions: ') print(positions)
332
1
"""simple docstring""" import pprint import requests _lowercase : Optional[Any] = 'https://zenquotes.io/api' def lowercase__ ( ): return requests.get(API_ENDPOINT_URL + '''/today''' ).json() def lowercase__ ( ): return requests.get(API_ENDPOINT_URL + '''/random''' ).json() if __name__ == "__main__": _lowercase : int = random_quotes() pprint.pprint(response)
332
"""simple docstring""" from __future__ import annotations from collections import deque from collections.abc import Sequence from dataclasses import dataclass from typing import Any @dataclass class _UpperCAmelCase : a__ : int a__ : Node | None = None a__ : Node | None = None def lowercase__ ( ): __UpperCAmelCase = Node(1 ) __UpperCAmelCase = Node(2 ) __UpperCAmelCase = Node(3 ) __UpperCAmelCase = Node(4 ) __UpperCAmelCase = Node(5 ) return tree def lowercase__ ( snake_case_ :Node | None ): return [root.data, *preorder(root.left ), *preorder(root.right )] if root else [] def lowercase__ ( snake_case_ :Node | None ): return postorder(root.left ) + postorder(root.right ) + [root.data] if root else [] def lowercase__ ( snake_case_ :Node | None ): return [*inorder(root.left ), root.data, *inorder(root.right )] if root else [] def lowercase__ ( snake_case_ :Node | None ): return (max(height(root.left ) , height(root.right ) ) + 1) if root else 0 def lowercase__ ( snake_case_ :Node | None ): __UpperCAmelCase = [] if root is None: return output __UpperCAmelCase = deque([root] ) while process_queue: __UpperCAmelCase = process_queue.popleft() output.append(node.data ) if node.left: process_queue.append(node.left ) if node.right: process_queue.append(node.right ) return output def lowercase__ ( snake_case_ :Node | None , snake_case_ :int ): __UpperCAmelCase = [] def populate_output(snake_case_ :Node | None , snake_case_ :int ) -> None: if not root: return if level == 1: output.append(root.data ) elif level > 1: populate_output(root.left , level - 1 ) populate_output(root.right , level - 1 ) populate_output(snake_case_ , snake_case_ ) return output def lowercase__ ( snake_case_ :Node | None , snake_case_ :int ): __UpperCAmelCase = [] def populate_output(snake_case_ :Node | None , snake_case_ :int ) -> None: if root is None: return if level == 1: output.append(root.data ) elif level > 1: populate_output(root.right , level - 1 ) populate_output(root.left , level - 1 ) populate_output(snake_case_ , snake_case_ ) return output def lowercase__ ( snake_case_ :Node | None ): if root is None: return [] __UpperCAmelCase = [] __UpperCAmelCase = 0 __UpperCAmelCase = height(snake_case_ ) for h in range(1 , height_tree + 1 ): if not flag: output.append(get_nodes_from_left_to_right(snake_case_ , snake_case_ ) ) __UpperCAmelCase = 1 else: output.append(get_nodes_from_right_to_left(snake_case_ , snake_case_ ) ) __UpperCAmelCase = 0 return output def lowercase__ ( ): # Main function for testing. __UpperCAmelCase = make_tree() print(F'''In-order Traversal: {inorder(snake_case_ )}''' ) print(F'''Pre-order Traversal: {preorder(snake_case_ )}''' ) print(F'''Post-order Traversal: {postorder(snake_case_ )}''' , '''\n''' ) print(F'''Height of Tree: {height(snake_case_ )}''' , '''\n''' ) print('''Complete Level Order Traversal: ''' ) print(level_order(snake_case_ ) , '''\n''' ) print('''Level-wise order Traversal: ''' ) for level in range(1 , height(snake_case_ ) + 1 ): print(F'''Level {level}:''' , get_nodes_from_left_to_right(snake_case_ , level=snake_case_ ) ) print('''\nZigZag order Traversal: ''' ) print(zigzag(snake_case_ ) ) if __name__ == "__main__": import doctest doctest.testmod() main()
332
1
"""simple docstring""" def lowercase__ ( snake_case_ :Union[str, Any] ): # if the collection is empty, returns empty if collection == []: return [] # get some information about the collection __UpperCAmelCase = len(snake_case_ ) __UpperCAmelCase = max(snake_case_ ) __UpperCAmelCase = min(snake_case_ ) # create the counting array __UpperCAmelCase = coll_max + 1 - coll_min __UpperCAmelCase = [0] * counting_arr_length # count how much a number appears in the collection for number in collection: counting_arr[number - coll_min] += 1 # sum each position with it's predecessors. now, counting_arr[i] tells # us how many elements <= i has in the collection for i in range(1 , snake_case_ ): __UpperCAmelCase = counting_arr[i] + counting_arr[i - 1] # create the output collection __UpperCAmelCase = [0] * coll_len # place the elements in the output, respecting the original order (stable # sort) from end to begin, updating counting_arr for i in reversed(range(0 , snake_case_ ) ): __UpperCAmelCase = collection[i] counting_arr[collection[i] - coll_min] -= 1 return ordered def lowercase__ ( snake_case_ :str ): return "".join([chr(snake_case_ ) for i in counting_sort([ord(snake_case_ ) for c in string] )] ) if __name__ == "__main__": # Test string sort assert counting_sort_string('thisisthestring') == "eghhiiinrsssttt" _lowercase : int = input('Enter numbers separated by a comma:\n').strip() _lowercase : int = [int(item) for item in user_input.split(',')] print(counting_sort(unsorted))
332
"""simple docstring""" import unittest from transformers import is_torch_available from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow if is_torch_available(): import torch from transformers import XLMRobertaModel @require_sentencepiece @require_tokenizers @require_torch class _UpperCAmelCase ( unittest.TestCase ): @slow def a ( self : str ): __UpperCAmelCase = XLMRobertaModel.from_pretrained('''xlm-roberta-base''' ) __UpperCAmelCase = torch.tensor([[0, 5_81, 1_02_69, 83, 9_99_42, 1_36, 6_07_42, 23, 70, 8_05_83, 1_82_76, 2]] ) # The dog is cute and lives in the garden house __UpperCAmelCase = torch.Size((1, 12, 7_68) ) # batch_size, sequence_length, embedding_vector_dim __UpperCAmelCase = torch.tensor( [[-0.0_101, 0.1_218, -0.0_803, 0.0_801, 0.1_327, 0.0_776, -0.1_215, 0.2_383, 0.3_338, 0.3_106, 0.0_300, 0.0_252]] ) # xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.base') # xlmr.eval() # expected_output_values_last_dim = xlmr.extract_features(input_ids[0])[:, :, -1] with torch.no_grad(): __UpperCAmelCase = model(_lowercase )['''last_hidden_state'''].detach() self.assertEqual(output.shape , _lowercase ) # compare the actual values for a slice of last dim self.assertTrue(torch.allclose(output[:, :, -1] , _lowercase , atol=1E-3 ) ) @slow def a ( self : str ): __UpperCAmelCase = XLMRobertaModel.from_pretrained('''xlm-roberta-large''' ) __UpperCAmelCase = torch.tensor([[0, 5_81, 1_02_69, 83, 9_99_42, 1_36, 6_07_42, 23, 70, 8_05_83, 1_82_76, 2]] ) # The dog is cute and lives in the garden house __UpperCAmelCase = torch.Size((1, 12, 10_24) ) # batch_size, sequence_length, embedding_vector_dim __UpperCAmelCase = torch.tensor( [[-0.0_699, -0.0_318, 0.0_705, -0.1_241, 0.0_999, -0.0_520, 0.1_004, -0.1_838, -0.4_704, 0.1_437, 0.0_821, 0.0_126]] ) # xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.large') # xlmr.eval() # expected_output_values_last_dim = xlmr.extract_features(input_ids[0])[:, :, -1] with torch.no_grad(): __UpperCAmelCase = model(_lowercase )['''last_hidden_state'''].detach() self.assertEqual(output.shape , _lowercase ) # compare the actual values for a slice of last dim self.assertTrue(torch.allclose(output[:, :, -1] , _lowercase , atol=1E-3 ) )
332
1
"""simple docstring""" from ...utils import ( OptionalDependencyNotAvailable, is_torch_available, is_transformers_available, is_transformers_version, ) try: if not (is_transformers_available() and is_torch_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ...utils.dummy_torch_and_transformers_objects import ( ImageTextPipelineOutput, UniDiffuserPipeline, ) else: from .modeling_text_decoder import UniDiffuserTextDecoder from .modeling_uvit import UniDiffuserModel, UTransformeraDModel from .pipeline_unidiffuser import ImageTextPipelineOutput, UniDiffuserPipeline
332
"""simple docstring""" def lowercase__ ( snake_case_ :Union[str, Any] ): # if the collection is empty, returns empty if collection == []: return [] # get some information about the collection __UpperCAmelCase = len(snake_case_ ) __UpperCAmelCase = max(snake_case_ ) __UpperCAmelCase = min(snake_case_ ) # create the counting array __UpperCAmelCase = coll_max + 1 - coll_min __UpperCAmelCase = [0] * counting_arr_length # count how much a number appears in the collection for number in collection: counting_arr[number - coll_min] += 1 # sum each position with it's predecessors. now, counting_arr[i] tells # us how many elements <= i has in the collection for i in range(1 , snake_case_ ): __UpperCAmelCase = counting_arr[i] + counting_arr[i - 1] # create the output collection __UpperCAmelCase = [0] * coll_len # place the elements in the output, respecting the original order (stable # sort) from end to begin, updating counting_arr for i in reversed(range(0 , snake_case_ ) ): __UpperCAmelCase = collection[i] counting_arr[collection[i] - coll_min] -= 1 return ordered def lowercase__ ( snake_case_ :str ): return "".join([chr(snake_case_ ) for i in counting_sort([ord(snake_case_ ) for c in string] )] ) if __name__ == "__main__": # Test string sort assert counting_sort_string('thisisthestring') == "eghhiiinrsssttt" _lowercase : int = input('Enter numbers separated by a comma:\n').strip() _lowercase : int = [int(item) for item in user_input.split(',')] print(counting_sort(unsorted))
332
1
"""simple docstring""" import os def lowercase__ ( snake_case_ :Optional[Any] ): __UpperCAmelCase = len(grid[0] ) __UpperCAmelCase = len(snake_case_ ) __UpperCAmelCase = 0 __UpperCAmelCase = 0 __UpperCAmelCase = 0 # Check vertically, horizontally, diagonally at the same time (only works # for nxn grid) for i in range(snake_case_ ): for j in range(n_rows - 3 ): __UpperCAmelCase = grid[j][i] * grid[j + 1][i] * grid[j + 2][i] * grid[j + 3][i] __UpperCAmelCase = grid[i][j] * grid[i][j + 1] * grid[i][j + 2] * grid[i][j + 3] # Left-to-right diagonal (\) product if i < n_columns - 3: __UpperCAmelCase = ( grid[i][j] * grid[i + 1][j + 1] * grid[i + 2][j + 2] * grid[i + 3][j + 3] ) # Right-to-left diagonal(/) product if i > 2: __UpperCAmelCase = ( grid[i][j] * grid[i - 1][j + 1] * grid[i - 2][j + 2] * grid[i - 3][j + 3] ) __UpperCAmelCase = max( snake_case_ , snake_case_ , snake_case_ , snake_case_ ) if max_product > largest: __UpperCAmelCase = max_product return largest def lowercase__ ( ): __UpperCAmelCase = [] with open(os.path.dirname(snake_case_ ) + '''/grid.txt''' ) as file: for line in file: grid.append(line.strip('''\n''' ).split(''' ''' ) ) __UpperCAmelCase = [[int(snake_case_ ) for i in grid[j]] for j in range(len(snake_case_ ) )] return largest_product(snake_case_ ) if __name__ == "__main__": print(solution())
332
"""simple docstring""" from collections import defaultdict def lowercase__ ( snake_case_ :str , snake_case_ :str ): __UpperCAmelCase = first_str.lower().strip() __UpperCAmelCase = second_str.lower().strip() # Remove whitespace __UpperCAmelCase = first_str.replace(''' ''' , '''''' ) __UpperCAmelCase = second_str.replace(''' ''' , '''''' ) # Strings of different lengths are not anagrams if len(snake_case_ ) != len(snake_case_ ): return False # Default values for count should be 0 __UpperCAmelCase = defaultdict(snake_case_ ) # For each character in input strings, # increment count in the corresponding for i in range(len(snake_case_ ) ): 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() _lowercase : List[Any] = input('Enter the first string ').strip() _lowercase : Tuple = input('Enter the second string ').strip() _lowercase : str = check_anagrams(input_a, input_b) print(f"""{input_a} and {input_b} are {"" if status else "not "}anagrams.""")
332
1
"""simple docstring""" import builtins import sys from ...utils.imports import _is_package_available from . import cursor, input from .helpers import Direction, clear_line, forceWrite, linebreak, move_cursor, reset_cursor, writeColor from .keymap import KEYMAP _lowercase : List[str] = False try: _lowercase : Dict = _is_package_available('google.colab') except ModuleNotFoundError: pass @input.register class _UpperCAmelCase : def __init__( self : List[Any] , _lowercase : str = None , _lowercase : list = [] ): __UpperCAmelCase = 0 __UpperCAmelCase = choices __UpperCAmelCase = prompt if sys.platform == "win32": __UpperCAmelCase = '''*''' else: __UpperCAmelCase = '''➔ ''' def a ( self : Tuple , _lowercase : int , _lowercase : str = "" ): if sys.platform != "win32": writeColor(self.choices[index] , 32 , _lowercase ) else: forceWrite(self.choices[index] , _lowercase ) def a ( self : Optional[int] , _lowercase : int ): if index == self.position: forceWrite(F''' {self.arrow_char} ''' ) self.write_choice(_lowercase ) else: forceWrite(F''' {self.choices[index]}''' ) reset_cursor() def a ( self : Tuple , _lowercase : Direction , _lowercase : int = 1 ): __UpperCAmelCase = self.position if direction == Direction.DOWN: if self.position + 1 >= len(self.choices ): return self.position += num_spaces else: if self.position - 1 < 0: return self.position -= num_spaces clear_line() self.print_choice(_lowercase ) move_cursor(_lowercase , direction.name ) self.print_choice(self.position ) @input.mark(KEYMAP['''up'''] ) def a ( self : List[Any] ): self.move_direction(Direction.UP ) @input.mark(KEYMAP['''down'''] ) def a ( self : Tuple ): self.move_direction(Direction.DOWN ) @input.mark(KEYMAP['''newline'''] ) def a ( self : str ): move_cursor(len(self.choices ) - self.position , '''DOWN''' ) return self.position @input.mark(KEYMAP['''interrupt'''] ) def a ( self : Tuple ): move_cursor(len(self.choices ) - self.position , '''DOWN''' ) raise KeyboardInterrupt @input.mark_multiple(*[KEYMAP[str(_lowercase )] for number in range(10 )] ) def a ( self : Dict ): __UpperCAmelCase = int(chr(self.current_selection ) ) __UpperCAmelCase = index - self.position if index == self.position: return if index < len(self.choices ): if self.position > index: self.move_direction(Direction.UP , -movement ) elif self.position < index: self.move_direction(Direction.DOWN , _lowercase ) else: return else: return def a ( self : Optional[Any] , _lowercase : int = 0 ): if self.prompt: linebreak() forceWrite(self.prompt , '''\n''' ) if in_colab: forceWrite('''Please input a choice index (starting from 0), and press enter''' , '''\n''' ) else: forceWrite('''Please select a choice using the arrow or number keys, and selecting with enter''' , '''\n''' ) __UpperCAmelCase = default_choice for i in range(len(self.choices ) ): self.print_choice(_lowercase ) forceWrite('''\n''' ) move_cursor(len(self.choices ) - self.position , '''UP''' ) with cursor.hide(): while True: if in_colab: try: __UpperCAmelCase = int(builtins.input() ) except ValueError: __UpperCAmelCase = default_choice else: __UpperCAmelCase = self.handle_input() if choice is not None: reset_cursor() for _ in range(len(self.choices ) + 1 ): move_cursor(1 , '''UP''' ) clear_line() self.write_choice(_lowercase , '''\n''' ) return choice
332
"""simple docstring""" import os import tempfile import unittest from pathlib import Path from transformers import AutoConfig, is_torch_available from transformers.testing_utils import require_torch, torch_device if is_torch_available(): from transformers import PyTorchBenchmark, PyTorchBenchmarkArguments @require_torch class _UpperCAmelCase ( unittest.TestCase ): def a ( self : Dict , _lowercase : Union[str, Any] ): for model_result in results.values(): for batch_size, sequence_length in zip(model_result['''bs'''] , model_result['''ss'''] ): __UpperCAmelCase = model_result['''result'''][batch_size][sequence_length] self.assertIsNotNone(_lowercase ) def a ( self : str ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : List[str] ): __UpperCAmelCase = '''sgugger/tiny-distilbert-classification''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , only_pretrain_model=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : str ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , torchscript=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) @unittest.skipIf(torch_device == '''cpu''' , '''Cant do half precision''' ) def a ( self : Optional[Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , fpaa=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : int ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) # set architectures equal to `None` __UpperCAmelCase = None __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : Tuple ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) @unittest.skipIf(torch_device == '''cpu''' , '''Can\'t do half precision''' ) def a ( self : Optional[Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , fpaa=_lowercase , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) def a ( self : Any ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : str ): __UpperCAmelCase = '''sshleifer/tinier_bart''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : Union[str, Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) def a ( self : int ): __UpperCAmelCase = '''sshleifer/tinier_bart''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) def a ( self : Optional[Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' with tempfile.TemporaryDirectory() as tmp_dir: __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , save_to_csv=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , inference_time_csv_file=os.path.join(_lowercase , '''inf_time.csv''' ) , train_memory_csv_file=os.path.join(_lowercase , '''train_mem.csv''' ) , inference_memory_csv_file=os.path.join(_lowercase , '''inf_mem.csv''' ) , train_time_csv_file=os.path.join(_lowercase , '''train_time.csv''' ) , env_info_csv_file=os.path.join(_lowercase , '''env.csv''' ) , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) benchmark.run() self.assertTrue(Path(os.path.join(_lowercase , '''inf_time.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(_lowercase , '''train_time.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(_lowercase , '''inf_mem.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(_lowercase , '''train_mem.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(_lowercase , '''env.csv''' ) ).exists() ) def a ( self : List[Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' def _check_summary_is_not_empty(_lowercase : str ): self.assertTrue(hasattr(_lowercase , '''sequential''' ) ) self.assertTrue(hasattr(_lowercase , '''cumulative''' ) ) self.assertTrue(hasattr(_lowercase , '''current''' ) ) self.assertTrue(hasattr(_lowercase , '''total''' ) ) with tempfile.TemporaryDirectory() as tmp_dir: __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , log_filename=os.path.join(_lowercase , '''log.txt''' ) , log_print=_lowercase , trace_memory_line_by_line=_lowercase , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() _check_summary_is_not_empty(result.inference_summary ) _check_summary_is_not_empty(result.train_summary ) self.assertTrue(Path(os.path.join(_lowercase , '''log.txt''' ) ).exists() )
332
1
"""simple docstring""" import sys import webbrowser import requests from bsa import BeautifulSoup from fake_useragent import UserAgent if __name__ == "__main__": print('Googling.....') _lowercase : str = 'https://www.google.com/search?q=' + ' '.join(sys.argv[1:]) _lowercase : List[Any] = requests.get(url, headers={'UserAgent': UserAgent().random}) # res.raise_for_status() with open('project1a.html', 'wb') as out_file: # only for knowing the class for data in res.iter_content(1_00_00): out_file.write(data) _lowercase : Optional[int] = BeautifulSoup(res.text, 'html.parser') _lowercase : List[Any] = list(soup.select('.eZt8xd'))[:5] print(len(links)) for link in links: if link.text == "Maps": webbrowser.open(link.get('href')) else: webbrowser.open(f"""https://google.com{link.get("href")}""")
332
"""simple docstring""" from typing import Dict from .base import GenericTensor, Pipeline class _UpperCAmelCase ( _lowerCAmelCase ): def a ( self : Tuple , _lowercase : Dict=None , _lowercase : str=None , _lowercase : Union[str, Any]=None , **_lowercase : Tuple ): if tokenize_kwargs is None: __UpperCAmelCase = {} if truncation is not None: if "truncation" in tokenize_kwargs: raise ValueError( '''truncation parameter defined twice (given as keyword argument as well as in tokenize_kwargs)''' ) __UpperCAmelCase = truncation __UpperCAmelCase = tokenize_kwargs __UpperCAmelCase = {} if return_tensors is not None: __UpperCAmelCase = return_tensors return preprocess_params, {}, postprocess_params def a ( self : int , _lowercase : Optional[Any] , **_lowercase : Union[str, Any] ): __UpperCAmelCase = self.framework __UpperCAmelCase = self.tokenizer(_lowercase , return_tensors=_lowercase , **_lowercase ) return model_inputs def a ( self : List[str] , _lowercase : Tuple ): __UpperCAmelCase = self.model(**_lowercase ) return model_outputs def a ( self : int , _lowercase : Tuple , _lowercase : str=False ): # [0] is the first available tensor, logits or last_hidden_state. if return_tensors: return model_outputs[0] if self.framework == "pt": return model_outputs[0].tolist() elif self.framework == "tf": return model_outputs[0].numpy().tolist() def __call__( self : List[Any] , *_lowercase : Optional[Any] , **_lowercase : Union[str, Any] ): return super().__call__(*_lowercase , **_lowercase )
332
1
"""simple docstring""" from collections import UserDict from typing import Union import numpy as np import requests from ..utils import ( add_end_docstrings, logging, ) from .audio_classification import ffmpeg_read from .base import PIPELINE_INIT_ARGS, Pipeline _lowercase : Union[str, Any] = logging.get_logger(__name__) @add_end_docstrings(_lowerCAmelCase ) class _UpperCAmelCase ( _lowerCAmelCase ): def __init__( self : Any , **_lowercase : Tuple ): super().__init__(**_lowercase ) if self.framework != "pt": raise ValueError(F'''The {self.__class__} is only available in PyTorch.''' ) # No specific FOR_XXX available yet def __call__( self : Tuple , _lowercase : Union[np.ndarray, bytes, str] , **_lowercase : Optional[int] ): return super().__call__(_lowercase , **_lowercase ) def a ( self : Any , **_lowercase : List[str] ): __UpperCAmelCase = {} if "candidate_labels" in kwargs: __UpperCAmelCase = kwargs['''candidate_labels'''] if "hypothesis_template" in kwargs: __UpperCAmelCase = kwargs['''hypothesis_template'''] return preprocess_params, {}, {} def a ( self : List[str] , _lowercase : int , _lowercase : str=None , _lowercase : int="This is a sound of {}." ): if isinstance(_lowercase , _lowercase ): if audio.startswith('''http://''' ) or audio.startswith('''https://''' ): # We need to actually check for a real protocol, otherwise it's impossible to use a local file # like http_huggingface_co.png __UpperCAmelCase = requests.get(_lowercase ).content else: with open(_lowercase , '''rb''' ) as f: __UpperCAmelCase = f.read() if isinstance(_lowercase , _lowercase ): __UpperCAmelCase = ffmpeg_read(_lowercase , self.feature_extractor.sampling_rate ) if not isinstance(_lowercase , np.ndarray ): raise ValueError('''We expect a numpy ndarray as input''' ) if len(audio.shape ) != 1: raise ValueError('''We expect a single channel audio input for ZeroShotAudioClassificationPipeline''' ) __UpperCAmelCase = self.feature_extractor( [audio] , sampling_rate=self.feature_extractor.sampling_rate , return_tensors='''pt''' ) __UpperCAmelCase = candidate_labels __UpperCAmelCase = [hypothesis_template.format(_lowercase ) for x in candidate_labels] __UpperCAmelCase = self.tokenizer(_lowercase , return_tensors=self.framework , padding=_lowercase ) __UpperCAmelCase = [text_inputs] return inputs def a ( self : Optional[int] , _lowercase : Optional[int] ): __UpperCAmelCase = model_inputs.pop('''candidate_labels''' ) __UpperCAmelCase = model_inputs.pop('''text_inputs''' ) if isinstance(text_inputs[0] , _lowercase ): __UpperCAmelCase = text_inputs[0] else: # Batching case. __UpperCAmelCase = text_inputs[0][0] __UpperCAmelCase = self.model(**_lowercase , **_lowercase ) __UpperCAmelCase = { '''candidate_labels''': candidate_labels, '''logits''': outputs.logits_per_audio, } return model_outputs def a ( self : Dict , _lowercase : List[str] ): __UpperCAmelCase = model_outputs.pop('''candidate_labels''' ) __UpperCAmelCase = model_outputs['''logits'''][0] if self.framework == "pt": __UpperCAmelCase = logits.softmax(dim=0 ) __UpperCAmelCase = probs.tolist() else: raise ValueError('''`tf` framework not supported.''' ) __UpperCAmelCase = [ {'''score''': score, '''label''': candidate_label} for score, candidate_label in sorted(zip(_lowercase , _lowercase ) , key=lambda _lowercase : -x[0] ) ] return result
332
"""simple docstring""" from typing import List, Optional, Tuple, Union import PIL import torch from torchvision import transforms from diffusers.pipeline_utils import DiffusionPipeline, ImagePipelineOutput from diffusers.schedulers import DDIMScheduler from diffusers.utils import randn_tensor _lowercase : Union[str, Any] = transforms.Compose( [ transforms.Resize((2_56, 2_56)), transforms.ToTensor(), transforms.Normalize([0.5], [0.5]), ] ) def lowercase__ ( snake_case_ :List[Any] ): if isinstance(snake_case_ , torch.Tensor ): return image elif isinstance(snake_case_ , PIL.Image.Image ): __UpperCAmelCase = [image] __UpperCAmelCase = [trans(img.convert('''RGB''' ) ) for img in image] __UpperCAmelCase = torch.stack(snake_case_ ) return image class _UpperCAmelCase ( _lowerCAmelCase ): def __init__( self : Any , _lowercase : str , _lowercase : str ): super().__init__() # make sure scheduler can always be converted to DDIM __UpperCAmelCase = DDIMScheduler.from_config(scheduler.config ) self.register_modules(unet=_lowercase , scheduler=_lowercase ) def a ( self : int , _lowercase : List[str] ): if strength < 0 or strength > 1: raise ValueError(F'''The value of strength should in [0.0, 1.0] but is {strength}''' ) def a ( self : List[Any] , _lowercase : List[Any] , _lowercase : Optional[Any] , _lowercase : int ): # get the original timestep using init_timestep __UpperCAmelCase = min(int(num_inference_steps * strength ) , _lowercase ) __UpperCAmelCase = max(num_inference_steps - init_timestep , 0 ) __UpperCAmelCase = self.scheduler.timesteps[t_start:] return timesteps, num_inference_steps - t_start def a ( self : Optional[Any] , _lowercase : Union[str, Any] , _lowercase : Union[str, Any] , _lowercase : Optional[Any] , _lowercase : List[str] , _lowercase : Tuple , _lowercase : Optional[int]=None ): if not isinstance(_lowercase , (torch.Tensor, PIL.Image.Image, list) ): raise ValueError( F'''`image` has to be of type `torch.Tensor`, `PIL.Image.Image` or list but is {type(_lowercase )}''' ) __UpperCAmelCase = image.to(device=_lowercase , dtype=_lowercase ) 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.''' ) __UpperCAmelCase = init_latents.shape __UpperCAmelCase = randn_tensor(_lowercase , generator=_lowercase , device=_lowercase , dtype=_lowercase ) # get latents print('''add noise to latents at timestep''' , _lowercase ) __UpperCAmelCase = self.scheduler.add_noise(_lowercase , _lowercase , _lowercase ) __UpperCAmelCase = init_latents return latents @torch.no_grad() def __call__( self : Any , _lowercase : Union[torch.FloatTensor, PIL.Image.Image] = None , _lowercase : float = 0.8 , _lowercase : int = 1 , _lowercase : Optional[Union[torch.Generator, List[torch.Generator]]] = None , _lowercase : float = 0.0 , _lowercase : int = 50 , _lowercase : Optional[bool] = None , _lowercase : Optional[str] = "pil" , _lowercase : bool = True , ): self.check_inputs(_lowercase ) # 2. Preprocess image __UpperCAmelCase = preprocess(_lowercase ) # 3. set timesteps self.scheduler.set_timesteps(_lowercase , device=self.device ) __UpperCAmelCase , __UpperCAmelCase = self.get_timesteps(_lowercase , _lowercase , self.device ) __UpperCAmelCase = timesteps[:1].repeat(_lowercase ) # 4. Prepare latent variables __UpperCAmelCase = self.prepare_latents(_lowercase , _lowercase , _lowercase , self.unet.dtype , self.device , _lowercase ) __UpperCAmelCase = latents # 5. Denoising loop for t in self.progress_bar(_lowercase ): # 1. predict noise model_output __UpperCAmelCase = 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 __UpperCAmelCase = self.scheduler.step( _lowercase , _lowercase , _lowercase , eta=_lowercase , use_clipped_model_output=_lowercase , generator=_lowercase , ).prev_sample __UpperCAmelCase = (image / 2 + 0.5).clamp(0 , 1 ) __UpperCAmelCase = image.cpu().permute(0 , 2 , 3 , 1 ).numpy() if output_type == "pil": __UpperCAmelCase = self.numpy_to_pil(_lowercase ) if not return_dict: return (image, latent_timestep.item()) return ImagePipelineOutput(images=_lowercase )
332
1
"""simple docstring""" from maths.prime_check import is_prime def lowercase__ ( snake_case_ :int ): if not isinstance(snake_case_ , snake_case_ ): __UpperCAmelCase = F'''Input value of [number={number}] must be an integer''' raise TypeError(snake_case_ ) if is_prime(snake_case_ ) and is_prime(number + 2 ): return number + 2 else: return -1 if __name__ == "__main__": import doctest doctest.testmod()
332
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, ) _lowercase : Union[str, Any] = { 'configuration_resnet': ['RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ResNetConfig', 'ResNetOnnxConfig'] } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : int = [ 'RESNET_PRETRAINED_MODEL_ARCHIVE_LIST', 'ResNetForImageClassification', 'ResNetModel', 'ResNetPreTrainedModel', 'ResNetBackbone', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : Union[str, Any] = [ 'TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST', 'TFResNetForImageClassification', 'TFResNetModel', 'TFResNetPreTrainedModel', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : Optional[int] = [ '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 _lowercase : Dict = _LazyModule(__name__, globals()['__file__'], _import_structure)
332
1
"""simple docstring""" from dataclasses import dataclass from typing import Optional, Tuple, Union import numpy as np import torch from ..configuration_utils import ConfigMixin, register_to_config from ..utils import BaseOutput, randn_tensor from .scheduling_utils import SchedulerMixin @dataclass class _UpperCAmelCase ( _lowerCAmelCase ): a__ : torch.FloatTensor a__ : torch.FloatTensor a__ : Optional[torch.FloatTensor] = None class _UpperCAmelCase ( _lowerCAmelCase , _lowerCAmelCase ): a__ : int = 2 @register_to_config def __init__( self : Union[str, Any] , _lowercase : float = 0.02 , _lowercase : float = 1_00 , _lowercase : float = 1.007 , _lowercase : float = 80 , _lowercase : float = 0.05 , _lowercase : float = 50 , ): # standard deviation of the initial noise distribution __UpperCAmelCase = sigma_max # setable values __UpperCAmelCase = None __UpperCAmelCase = None __UpperCAmelCase = None # sigma(t_i) def a ( self : Union[str, Any] , _lowercase : torch.FloatTensor , _lowercase : Optional[int] = None ): return sample def a ( self : Any , _lowercase : int , _lowercase : Union[str, torch.device] = None ): __UpperCAmelCase = num_inference_steps __UpperCAmelCase = np.arange(0 , self.num_inference_steps )[::-1].copy() __UpperCAmelCase = torch.from_numpy(_lowercase ).to(_lowercase ) __UpperCAmelCase = [ ( self.config.sigma_max**2 * (self.config.sigma_min**2 / self.config.sigma_max**2) ** (i / (num_inference_steps - 1)) ) for i in self.timesteps ] __UpperCAmelCase = torch.tensor(_lowercase , dtype=torch.floataa , device=_lowercase ) def a ( self : Optional[int] , _lowercase : torch.FloatTensor , _lowercase : float , _lowercase : Optional[torch.Generator] = None ): if self.config.s_min <= sigma <= self.config.s_max: __UpperCAmelCase = min(self.config.s_churn / self.num_inference_steps , 2**0.5 - 1 ) else: __UpperCAmelCase = 0 # sample eps ~ N(0, S_noise^2 * I) __UpperCAmelCase = self.config.s_noise * randn_tensor(sample.shape , generator=_lowercase ).to(sample.device ) __UpperCAmelCase = sigma + gamma * sigma __UpperCAmelCase = sample + ((sigma_hat**2 - sigma**2) ** 0.5 * eps) return sample_hat, sigma_hat def a ( self : Optional[Any] , _lowercase : torch.FloatTensor , _lowercase : float , _lowercase : float , _lowercase : torch.FloatTensor , _lowercase : bool = True , ): __UpperCAmelCase = sample_hat + sigma_hat * model_output __UpperCAmelCase = (sample_hat - pred_original_sample) / sigma_hat __UpperCAmelCase = sample_hat + (sigma_prev - sigma_hat) * derivative if not return_dict: return (sample_prev, derivative) return KarrasVeOutput( prev_sample=_lowercase , derivative=_lowercase , pred_original_sample=_lowercase ) def a ( self : Any , _lowercase : torch.FloatTensor , _lowercase : float , _lowercase : float , _lowercase : torch.FloatTensor , _lowercase : torch.FloatTensor , _lowercase : torch.FloatTensor , _lowercase : bool = True , ): __UpperCAmelCase = sample_prev + sigma_prev * model_output __UpperCAmelCase = (sample_prev - pred_original_sample) / sigma_prev __UpperCAmelCase = sample_hat + (sigma_prev - sigma_hat) * (0.5 * derivative + 0.5 * derivative_corr) if not return_dict: return (sample_prev, derivative) return KarrasVeOutput( prev_sample=_lowercase , derivative=_lowercase , pred_original_sample=_lowercase ) def a ( self : Optional[Any] , _lowercase : Union[str, Any] , _lowercase : List[Any] , _lowercase : str ): raise NotImplementedError()
332
"""simple docstring""" _lowercase : Any = '\n# Installazione di Transformers\n! pip install transformers datasets\n# Per installare dalla fonte invece dell\'ultima versione rilasciata, commenta il comando sopra e\n# rimuovi la modalità commento al comando seguente.\n# ! pip install git+https://github.com/huggingface/transformers.git\n' _lowercase : Tuple = [{'type': 'code', 'content': INSTALL_CONTENT}] _lowercase : int = { '{processor_class}': 'FakeProcessorClass', '{model_class}': 'FakeModelClass', '{object_class}': 'FakeObjectClass', }
332
1
"""simple docstring""" import json from typing import List, Optional, Tuple from tokenizers import normalizers from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_funnel import FunnelTokenizer _lowercase : Tuple = logging.get_logger(__name__) _lowercase : Tuple = {'vocab_file': 'vocab.txt', 'tokenizer_file': 'tokenizer.json'} _lowercase : Dict = [ 'small', 'small-base', 'medium', 'medium-base', 'intermediate', 'intermediate-base', 'large', 'large-base', 'xlarge', 'xlarge-base', ] _lowercase : str = { 'vocab_file': { 'funnel-transformer/small': 'https://huggingface.co/funnel-transformer/small/resolve/main/vocab.txt', 'funnel-transformer/small-base': 'https://huggingface.co/funnel-transformer/small-base/resolve/main/vocab.txt', 'funnel-transformer/medium': 'https://huggingface.co/funnel-transformer/medium/resolve/main/vocab.txt', 'funnel-transformer/medium-base': ( 'https://huggingface.co/funnel-transformer/medium-base/resolve/main/vocab.txt' ), 'funnel-transformer/intermediate': ( 'https://huggingface.co/funnel-transformer/intermediate/resolve/main/vocab.txt' ), 'funnel-transformer/intermediate-base': ( 'https://huggingface.co/funnel-transformer/intermediate-base/resolve/main/vocab.txt' ), 'funnel-transformer/large': 'https://huggingface.co/funnel-transformer/large/resolve/main/vocab.txt', 'funnel-transformer/large-base': 'https://huggingface.co/funnel-transformer/large-base/resolve/main/vocab.txt', 'funnel-transformer/xlarge': 'https://huggingface.co/funnel-transformer/xlarge/resolve/main/vocab.txt', 'funnel-transformer/xlarge-base': ( 'https://huggingface.co/funnel-transformer/xlarge-base/resolve/main/vocab.txt' ), }, 'tokenizer_file': { 'funnel-transformer/small': 'https://huggingface.co/funnel-transformer/small/resolve/main/tokenizer.json', 'funnel-transformer/small-base': ( 'https://huggingface.co/funnel-transformer/small-base/resolve/main/tokenizer.json' ), 'funnel-transformer/medium': 'https://huggingface.co/funnel-transformer/medium/resolve/main/tokenizer.json', 'funnel-transformer/medium-base': ( 'https://huggingface.co/funnel-transformer/medium-base/resolve/main/tokenizer.json' ), 'funnel-transformer/intermediate': ( 'https://huggingface.co/funnel-transformer/intermediate/resolve/main/tokenizer.json' ), 'funnel-transformer/intermediate-base': ( 'https://huggingface.co/funnel-transformer/intermediate-base/resolve/main/tokenizer.json' ), 'funnel-transformer/large': 'https://huggingface.co/funnel-transformer/large/resolve/main/tokenizer.json', 'funnel-transformer/large-base': ( 'https://huggingface.co/funnel-transformer/large-base/resolve/main/tokenizer.json' ), 'funnel-transformer/xlarge': 'https://huggingface.co/funnel-transformer/xlarge/resolve/main/tokenizer.json', 'funnel-transformer/xlarge-base': ( 'https://huggingface.co/funnel-transformer/xlarge-base/resolve/main/tokenizer.json' ), }, } _lowercase : Optional[Any] = {f"""funnel-transformer/{name}""": 5_12 for name in _model_names} _lowercase : Optional[Any] = {f"""funnel-transformer/{name}""": {'do_lower_case': True} for name in _model_names} class _UpperCAmelCase ( _lowerCAmelCase ): a__ : Dict = VOCAB_FILES_NAMES a__ : int = PRETRAINED_VOCAB_FILES_MAP a__ : Optional[int] = PRETRAINED_INIT_CONFIGURATION a__ : List[str] = FunnelTokenizer a__ : Optional[Any] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES a__ : int = 2 def __init__( self : List[str] , _lowercase : Any=None , _lowercase : Tuple=None , _lowercase : int=True , _lowercase : int="<unk>" , _lowercase : List[str]="<sep>" , _lowercase : Dict="<pad>" , _lowercase : Any="<cls>" , _lowercase : int="<mask>" , _lowercase : Optional[int]="<s>" , _lowercase : Optional[int]="</s>" , _lowercase : Tuple=True , _lowercase : List[Any]=True , _lowercase : Any=None , _lowercase : int="##" , **_lowercase : Optional[int] , ): super().__init__( _lowercase , tokenizer_file=_lowercase , do_lower_case=_lowercase , unk_token=_lowercase , sep_token=_lowercase , pad_token=_lowercase , cls_token=_lowercase , mask_token=_lowercase , bos_token=_lowercase , eos_token=_lowercase , clean_text=_lowercase , tokenize_chinese_chars=_lowercase , strip_accents=_lowercase , wordpieces_prefix=_lowercase , **_lowercase , ) __UpperCAmelCase = json.loads(self.backend_tokenizer.normalizer.__getstate__() ) if ( normalizer_state.get('''lowercase''' , _lowercase ) != do_lower_case or normalizer_state.get('''strip_accents''' , _lowercase ) != strip_accents or normalizer_state.get('''handle_chinese_chars''' , _lowercase ) != tokenize_chinese_chars ): __UpperCAmelCase = getattr(_lowercase , normalizer_state.pop('''type''' ) ) __UpperCAmelCase = do_lower_case __UpperCAmelCase = strip_accents __UpperCAmelCase = tokenize_chinese_chars __UpperCAmelCase = normalizer_class(**_lowercase ) __UpperCAmelCase = do_lower_case def a ( self : Union[str, Any] , _lowercase : str , _lowercase : Union[str, Any]=None ): __UpperCAmelCase = [self.cls_token_id] + token_ids_a + [self.sep_token_id] if token_ids_a: output += token_ids_a + [self.sep_token_id] return output def a ( self : Optional[int] , _lowercase : List[int] , _lowercase : Optional[List[int]] = None ): __UpperCAmelCase = [self.sep_token_id] __UpperCAmelCase = [self.cls_token_id] if token_ids_a is None: return len(cls ) * [self.cls_token_type_id] + len(token_ids_a + sep ) * [0] return len(cls ) * [self.cls_token_type_id] + len(token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def a ( self : str , _lowercase : str , _lowercase : Optional[str] = None ): __UpperCAmelCase = self._tokenizer.model.save(_lowercase , name=_lowercase ) return tuple(_lowercase )
332
"""simple docstring""" import importlib.util import os import platform from argparse import ArgumentParser import huggingface_hub from .. import __version__ as version from ..utils import ( is_accelerate_available, is_flax_available, is_safetensors_available, is_tf_available, is_torch_available, ) from . import BaseTransformersCLICommand def lowercase__ ( snake_case_ :Optional[int] ): return EnvironmentCommand() def lowercase__ ( snake_case_ :List[str] ): return EnvironmentCommand(args.accelerate_config_file ) class _UpperCAmelCase ( _lowerCAmelCase ): @staticmethod def a ( _lowercase : ArgumentParser ): __UpperCAmelCase = parser.add_parser('''env''' ) download_parser.set_defaults(func=_lowercase ) download_parser.add_argument( '''--accelerate-config_file''' , default=_lowercase , help='''The accelerate config file to use for the default values in the launching script.''' , ) download_parser.set_defaults(func=_lowercase ) def __init__( self : Optional[int] , _lowercase : str , *_lowercase : Tuple ): __UpperCAmelCase = accelerate_config_file def a ( self : Dict ): __UpperCAmelCase = '''not installed''' if is_safetensors_available(): import safetensors __UpperCAmelCase = safetensors.__version__ elif importlib.util.find_spec('''safetensors''' ) is not None: import safetensors __UpperCAmelCase = F'''{safetensors.__version__} but is ignored because of PyTorch version too old.''' __UpperCAmelCase = '''not installed''' __UpperCAmelCase = __UpperCAmelCase = '''not found''' if is_accelerate_available(): import accelerate from accelerate.commands.config import default_config_file, load_config_from_file __UpperCAmelCase = accelerate.__version__ # Get the default from the config file. if self._accelerate_config_file is not None or os.path.isfile(_lowercase ): __UpperCAmelCase = load_config_from_file(self._accelerate_config_file ).to_dict() __UpperCAmelCase = ( '''\n'''.join([F'''\t- {prop}: {val}''' for prop, val in accelerate_config.items()] ) if isinstance(_lowercase , _lowercase ) else F'''\t{accelerate_config}''' ) __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''NA''' if is_torch_available(): import torch __UpperCAmelCase = torch.__version__ __UpperCAmelCase = torch.cuda.is_available() __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''NA''' if is_tf_available(): import tensorflow as tf __UpperCAmelCase = tf.__version__ try: # deprecated in v2.1 __UpperCAmelCase = tf.test.is_gpu_available() except AttributeError: # returns list of devices, convert to bool __UpperCAmelCase = bool(tf.config.list_physical_devices('''GPU''' ) ) __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''NA''' if is_flax_available(): import flax import jax import jaxlib __UpperCAmelCase = flax.__version__ __UpperCAmelCase = jax.__version__ __UpperCAmelCase = jaxlib.__version__ __UpperCAmelCase = jax.lib.xla_bridge.get_backend().platform __UpperCAmelCase = { '''`transformers` version''': version, '''Platform''': platform.platform(), '''Python version''': platform.python_version(), '''Huggingface_hub version''': huggingface_hub.__version__, '''Safetensors version''': F'''{safetensors_version}''', '''Accelerate version''': F'''{accelerate_version}''', '''Accelerate config''': F'''{accelerate_config_str}''', '''PyTorch version (GPU?)''': F'''{pt_version} ({pt_cuda_available})''', '''Tensorflow version (GPU?)''': F'''{tf_version} ({tf_cuda_available})''', '''Flax version (CPU?/GPU?/TPU?)''': F'''{flax_version} ({jax_backend})''', '''Jax version''': F'''{jax_version}''', '''JaxLib version''': F'''{jaxlib_version}''', '''Using GPU in script?''': '''<fill in>''', '''Using distributed or parallel set-up in script?''': '''<fill in>''', } print('''\nCopy-and-paste the text below in your GitHub issue and FILL OUT the two last points.\n''' ) print(self.format_dict(_lowercase ) ) return info @staticmethod def a ( _lowercase : str ): return "\n".join([F'''- {prop}: {val}''' for prop, val in d.items()] ) + "\n"
332
1
"""simple docstring""" from typing import Dict, List, Optional, Tuple, Union import torch from ...models import AutoencoderKL, TransformeraDModel from ...schedulers import KarrasDiffusionSchedulers from ...utils import randn_tensor from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput class _UpperCAmelCase ( _lowerCAmelCase ): def __init__( self : int , _lowercase : TransformeraDModel , _lowercase : AutoencoderKL , _lowercase : KarrasDiffusionSchedulers , _lowercase : Optional[Dict[int, str]] = None , ): super().__init__() self.register_modules(transformer=_lowercase , vae=_lowercase , scheduler=_lowercase ) # create a imagenet -> id dictionary for easier use __UpperCAmelCase = {} if idalabel is not None: for key, value in idalabel.items(): for label in value.split(''',''' ): __UpperCAmelCase = int(_lowercase ) __UpperCAmelCase = dict(sorted(self.labels.items() ) ) def a ( self : str , _lowercase : Union[str, List[str]] ): if not isinstance(_lowercase , _lowercase ): __UpperCAmelCase = list(_lowercase ) for l in label: if l not in self.labels: raise ValueError( F'''{l} does not exist. Please make sure to select one of the following labels: \n {self.labels}.''' ) return [self.labels[l] for l in label] @torch.no_grad() def __call__( self : List[str] , _lowercase : List[int] , _lowercase : float = 4.0 , _lowercase : Optional[Union[torch.Generator, List[torch.Generator]]] = None , _lowercase : int = 50 , _lowercase : Optional[str] = "pil" , _lowercase : bool = True , ): __UpperCAmelCase = len(_lowercase ) __UpperCAmelCase = self.transformer.config.sample_size __UpperCAmelCase = self.transformer.config.in_channels __UpperCAmelCase = randn_tensor( shape=(batch_size, latent_channels, latent_size, latent_size) , generator=_lowercase , device=self.device , dtype=self.transformer.dtype , ) __UpperCAmelCase = torch.cat([latents] * 2 ) if guidance_scale > 1 else latents __UpperCAmelCase = torch.tensor(_lowercase , device=self.device ).reshape(-1 ) __UpperCAmelCase = torch.tensor([10_00] * batch_size , device=self.device ) __UpperCAmelCase = torch.cat([class_labels, class_null] , 0 ) if guidance_scale > 1 else class_labels # set step values self.scheduler.set_timesteps(_lowercase ) for t in self.progress_bar(self.scheduler.timesteps ): if guidance_scale > 1: __UpperCAmelCase = latent_model_input[: len(_lowercase ) // 2] __UpperCAmelCase = torch.cat([half, half] , dim=0 ) __UpperCAmelCase = self.scheduler.scale_model_input(_lowercase , _lowercase ) __UpperCAmelCase = t if not torch.is_tensor(_lowercase ): # TODO: this requires sync between CPU and GPU. So try to pass timesteps as tensors if you can # This would be a good case for the `match` statement (Python 3.10+) __UpperCAmelCase = latent_model_input.device.type == '''mps''' if isinstance(_lowercase , _lowercase ): __UpperCAmelCase = torch.floataa if is_mps else torch.floataa else: __UpperCAmelCase = torch.intaa if is_mps else torch.intaa __UpperCAmelCase = torch.tensor([timesteps] , dtype=_lowercase , device=latent_model_input.device ) elif len(timesteps.shape ) == 0: __UpperCAmelCase = timesteps[None].to(latent_model_input.device ) # broadcast to batch dimension in a way that's compatible with ONNX/Core ML __UpperCAmelCase = timesteps.expand(latent_model_input.shape[0] ) # predict noise model_output __UpperCAmelCase = self.transformer( _lowercase , timestep=_lowercase , class_labels=_lowercase ).sample # perform guidance if guidance_scale > 1: __UpperCAmelCase , __UpperCAmelCase = noise_pred[:, :latent_channels], noise_pred[:, latent_channels:] __UpperCAmelCase , __UpperCAmelCase = torch.split(_lowercase , len(_lowercase ) // 2 , dim=0 ) __UpperCAmelCase = uncond_eps + guidance_scale * (cond_eps - uncond_eps) __UpperCAmelCase = torch.cat([half_eps, half_eps] , dim=0 ) __UpperCAmelCase = torch.cat([eps, rest] , dim=1 ) # learned sigma if self.transformer.config.out_channels // 2 == latent_channels: __UpperCAmelCase , __UpperCAmelCase = torch.split(_lowercase , _lowercase , dim=1 ) else: __UpperCAmelCase = noise_pred # compute previous image: x_t -> x_t-1 __UpperCAmelCase = self.scheduler.step(_lowercase , _lowercase , _lowercase ).prev_sample if guidance_scale > 1: __UpperCAmelCase , __UpperCAmelCase = latent_model_input.chunk(2 , dim=0 ) else: __UpperCAmelCase = latent_model_input __UpperCAmelCase = 1 / self.vae.config.scaling_factor * latents __UpperCAmelCase = self.vae.decode(_lowercase ).sample __UpperCAmelCase = (samples / 2 + 0.5).clamp(0 , 1 ) # we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16 __UpperCAmelCase = samples.cpu().permute(0 , 2 , 3 , 1 ).float().numpy() if output_type == "pil": __UpperCAmelCase = self.numpy_to_pil(_lowercase ) if not return_dict: return (samples,) return ImagePipelineOutput(images=_lowercase )
332
"""simple docstring""" from __future__ import annotations def lowercase__ ( snake_case_ :list[float] , snake_case_ :list[float] ): __UpperCAmelCase = sorted(numsa + numsa ) __UpperCAmelCase , __UpperCAmelCase = divmod(len(snake_case_ ) , 2 ) if mod == 1: return all_numbers[div] else: return (all_numbers[div] + all_numbers[div - 1]) / 2 if __name__ == "__main__": import doctest doctest.testmod() _lowercase : int = [float(x) for x in input('Enter the elements of first array: ').split()] _lowercase : Tuple = [float(x) for x in input('Enter the elements of second array: ').split()] print(f"""The median of two arrays is: {median_of_two_arrays(array_a, array_a)}""")
332
1
"""simple docstring""" def lowercase__ ( snake_case_ :float ): return 10 - x * x def lowercase__ ( snake_case_ :float , snake_case_ :float ): # Bolzano theory in order to find if there is a root between a and b if equation(snake_case_ ) * equation(snake_case_ ) >= 0: raise ValueError('''Wrong space!''' ) __UpperCAmelCase = a while (b - a) >= 0.01: # Find middle point __UpperCAmelCase = (a + b) / 2 # Check if middle point is root if equation(snake_case_ ) == 0.0: break # Decide the side to repeat the steps if equation(snake_case_ ) * equation(snake_case_ ) < 0: __UpperCAmelCase = c else: __UpperCAmelCase = c return c if __name__ == "__main__": import doctest doctest.testmod() print(bisection(-2, 5)) print(bisection(0, 6))
332
"""simple docstring""" import heapq as hq import math from collections.abc import Iterator class _UpperCAmelCase : def __init__( self : Union[str, Any] , _lowercase : Optional[Any] ): __UpperCAmelCase = str(id_ ) __UpperCAmelCase = None __UpperCAmelCase = None __UpperCAmelCase = [] __UpperCAmelCase = {} # {vertex:distance} def __lt__( self : str , _lowercase : List[Any] ): return self.key < other.key def __repr__( self : int ): return self.id def a ( self : Union[str, Any] , _lowercase : int ): self.neighbors.append(_lowercase ) def a ( self : List[Any] , _lowercase : Optional[Any] , _lowercase : int ): __UpperCAmelCase = weight def lowercase__ ( snake_case_ :int , snake_case_ :Any , snake_case_ :Union[str, Any] , snake_case_ :List[str] ): # add the neighbors: graph[a - 1].add_neighbor(graph[b - 1] ) graph[b - 1].add_neighbor(graph[a - 1] ) # add the edges: graph[a - 1].add_edge(graph[b - 1] , snake_case_ ) graph[b - 1].add_edge(graph[a - 1] , snake_case_ ) def lowercase__ ( snake_case_ :list , snake_case_ :Vertex ): __UpperCAmelCase = [] for u in graph: __UpperCAmelCase = math.inf __UpperCAmelCase = None __UpperCAmelCase = 0 __UpperCAmelCase = graph[:] while q: __UpperCAmelCase = min(snake_case_ ) q.remove(snake_case_ ) for v in u.neighbors: if (v in q) and (u.edges[v.id] < v.key): __UpperCAmelCase = u __UpperCAmelCase = u.edges[v.id] for i in range(1 , len(snake_case_ ) ): a.append((int(graph[i].id ) + 1, int(graph[i].pi.id ) + 1) ) return a def lowercase__ ( snake_case_ :list , snake_case_ :Vertex ): for u in graph: __UpperCAmelCase = math.inf __UpperCAmelCase = None __UpperCAmelCase = 0 __UpperCAmelCase = list(snake_case_ ) hq.heapify(snake_case_ ) while h: __UpperCAmelCase = hq.heappop(snake_case_ ) for v in u.neighbors: if (v in h) and (u.edges[v.id] < v.key): __UpperCAmelCase = u __UpperCAmelCase = u.edges[v.id] hq.heapify(snake_case_ ) for i in range(1 , len(snake_case_ ) ): yield (int(graph[i].id ) + 1, int(graph[i].pi.id ) + 1) def lowercase__ ( ): pass if __name__ == "__main__": import doctest doctest.testmod()
332
1
"""simple docstring""" import argparse import json from collections import OrderedDict import torch from huggingface_hub import cached_download, hf_hub_url from transformers import AutoImageProcessor, CvtConfig, CvtForImageClassification def lowercase__ ( snake_case_ :Optional[int] ): __UpperCAmelCase = [] embed.append( ( F'''cvt.encoder.stages.{idx}.embedding.convolution_embeddings.projection.weight''', F'''stage{idx}.patch_embed.proj.weight''', ) ) embed.append( ( F'''cvt.encoder.stages.{idx}.embedding.convolution_embeddings.projection.bias''', F'''stage{idx}.patch_embed.proj.bias''', ) ) embed.append( ( F'''cvt.encoder.stages.{idx}.embedding.convolution_embeddings.normalization.weight''', F'''stage{idx}.patch_embed.norm.weight''', ) ) embed.append( ( F'''cvt.encoder.stages.{idx}.embedding.convolution_embeddings.normalization.bias''', F'''stage{idx}.patch_embed.norm.bias''', ) ) return embed def lowercase__ ( snake_case_ :Dict , snake_case_ :List[str] ): __UpperCAmelCase = [] attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.convolution.weight''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_q.conv.weight''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.weight''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.weight''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.bias''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.bias''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.running_mean''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.running_mean''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.running_var''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.running_var''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.num_batches_tracked''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.num_batches_tracked''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.convolution.weight''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_k.conv.weight''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.weight''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.weight''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.bias''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.bias''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.running_mean''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.running_mean''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.running_var''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.running_var''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.num_batches_tracked''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.num_batches_tracked''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.convolution.weight''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_v.conv.weight''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.weight''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.weight''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.bias''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.bias''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.running_mean''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.running_mean''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.running_var''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.running_var''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.num_batches_tracked''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.num_batches_tracked''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_query.weight''', F'''stage{idx}.blocks.{cnt}.attn.proj_q.weight''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_query.bias''', F'''stage{idx}.blocks.{cnt}.attn.proj_q.bias''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_key.weight''', F'''stage{idx}.blocks.{cnt}.attn.proj_k.weight''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_key.bias''', F'''stage{idx}.blocks.{cnt}.attn.proj_k.bias''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_value.weight''', F'''stage{idx}.blocks.{cnt}.attn.proj_v.weight''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_value.bias''', F'''stage{idx}.blocks.{cnt}.attn.proj_v.bias''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.output.dense.weight''', F'''stage{idx}.blocks.{cnt}.attn.proj.weight''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.output.dense.bias''', F'''stage{idx}.blocks.{cnt}.attn.proj.bias''', ) ) attention_weights.append( (F'''cvt.encoder.stages.{idx}.layers.{cnt}.intermediate.dense.weight''', F'''stage{idx}.blocks.{cnt}.mlp.fc1.weight''') ) attention_weights.append( (F'''cvt.encoder.stages.{idx}.layers.{cnt}.intermediate.dense.bias''', F'''stage{idx}.blocks.{cnt}.mlp.fc1.bias''') ) attention_weights.append( (F'''cvt.encoder.stages.{idx}.layers.{cnt}.output.dense.weight''', F'''stage{idx}.blocks.{cnt}.mlp.fc2.weight''') ) attention_weights.append( (F'''cvt.encoder.stages.{idx}.layers.{cnt}.output.dense.bias''', F'''stage{idx}.blocks.{cnt}.mlp.fc2.bias''') ) attention_weights.append( (F'''cvt.encoder.stages.{idx}.layers.{cnt}.layernorm_before.weight''', F'''stage{idx}.blocks.{cnt}.norm1.weight''') ) attention_weights.append( (F'''cvt.encoder.stages.{idx}.layers.{cnt}.layernorm_before.bias''', F'''stage{idx}.blocks.{cnt}.norm1.bias''') ) attention_weights.append( (F'''cvt.encoder.stages.{idx}.layers.{cnt}.layernorm_after.weight''', F'''stage{idx}.blocks.{cnt}.norm2.weight''') ) attention_weights.append( (F'''cvt.encoder.stages.{idx}.layers.{cnt}.layernorm_after.bias''', F'''stage{idx}.blocks.{cnt}.norm2.bias''') ) return attention_weights def lowercase__ ( snake_case_ :Optional[int] ): __UpperCAmelCase = [] token.append((F'''cvt.encoder.stages.{idx}.cls_token''', '''stage2.cls_token''') ) return token def lowercase__ ( ): __UpperCAmelCase = [] head.append(('''layernorm.weight''', '''norm.weight''') ) head.append(('''layernorm.bias''', '''norm.bias''') ) head.append(('''classifier.weight''', '''head.weight''') ) head.append(('''classifier.bias''', '''head.bias''') ) return head def lowercase__ ( snake_case_ :List[str] , snake_case_ :Optional[int] , snake_case_ :Union[str, Any] , snake_case_ :Any ): __UpperCAmelCase = '''imagenet-1k-id2label.json''' __UpperCAmelCase = 1_000 __UpperCAmelCase = '''huggingface/label-files''' __UpperCAmelCase = num_labels __UpperCAmelCase = json.load(open(cached_download(hf_hub_url(snake_case_ , snake_case_ , repo_type='''dataset''' ) ) , '''r''' ) ) __UpperCAmelCase = {int(snake_case_ ): v for k, v in idalabel.items()} __UpperCAmelCase = idalabel __UpperCAmelCase = {v: k for k, v in idalabel.items()} __UpperCAmelCase = __UpperCAmelCase = CvtConfig(num_labels=snake_case_ , idalabel=snake_case_ , labelaid=snake_case_ ) # For depth size 13 (13 = 1+2+10) if cvt_model.rsplit('''/''' , 1 )[-1][4:6] == "13": __UpperCAmelCase = [1, 2, 10] # For depth size 21 (21 = 1+4+16) elif cvt_model.rsplit('''/''' , 1 )[-1][4:6] == "21": __UpperCAmelCase = [1, 4, 16] # For wide cvt (similar to wide-resnet) depth size 24 (w24 = 2 + 2 20) else: __UpperCAmelCase = [2, 2, 20] __UpperCAmelCase = [3, 12, 16] __UpperCAmelCase = [192, 768, 1_024] __UpperCAmelCase = CvtForImageClassification(snake_case_ ) __UpperCAmelCase = AutoImageProcessor.from_pretrained('''facebook/convnext-base-224-22k-1k''' ) __UpperCAmelCase = image_size __UpperCAmelCase = torch.load(snake_case_ , map_location=torch.device('''cpu''' ) ) __UpperCAmelCase = OrderedDict() __UpperCAmelCase = [] for idx in range(len(config.depth ) ): if config.cls_token[idx]: __UpperCAmelCase = list_of_state_dict + cls_token(snake_case_ ) __UpperCAmelCase = list_of_state_dict + embeddings(snake_case_ ) for cnt in range(config.depth[idx] ): __UpperCAmelCase = list_of_state_dict + attention(snake_case_ , snake_case_ ) __UpperCAmelCase = list_of_state_dict + final() for gg in list_of_state_dict: print(snake_case_ ) for i in range(len(snake_case_ ) ): __UpperCAmelCase = original_weights[list_of_state_dict[i][1]] model.load_state_dict(snake_case_ ) model.save_pretrained(snake_case_ ) image_processor.save_pretrained(snake_case_ ) # Download the weights from zoo: https://1drv.ms/u/s!AhIXJn_J-blW9RzF3rMW7SsLHa8h?e=blQ0Al if __name__ == "__main__": _lowercase : Optional[int] = argparse.ArgumentParser() parser.add_argument( '--cvt_model', default='cvt-w24', type=str, help='Name of the cvt model you\'d like to convert.', ) parser.add_argument( '--image_size', default=3_84, type=int, help='Input Image Size', ) parser.add_argument( '--cvt_file_name', default=r'cvtmodels\CvT-w24-384x384-IN-22k.pth', type=str, help='Input Image Size', ) parser.add_argument( '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.' ) _lowercase : List[Any] = parser.parse_args() convert_cvt_checkpoint(args.cvt_model, args.image_size, args.cvt_file_name, args.pytorch_dump_folder_path)
332
"""simple docstring""" from ...configuration_utils import PretrainedConfig from ...utils import logging _lowercase : str = logging.get_logger(__name__) _lowercase : Dict = { 'microsoft/swinv2-tiny-patch4-window8-256': ( 'https://huggingface.co/microsoft/swinv2-tiny-patch4-window8-256/resolve/main/config.json' ), } class _UpperCAmelCase ( _lowerCAmelCase ): a__ : Tuple = "swinv2" a__ : List[Any] = { "num_attention_heads": "num_heads", "num_hidden_layers": "num_layers", } def __init__( self : Any , _lowercase : List[Any]=2_24 , _lowercase : int=4 , _lowercase : Optional[int]=3 , _lowercase : Optional[Any]=96 , _lowercase : Optional[int]=[2, 2, 6, 2] , _lowercase : Optional[int]=[3, 6, 12, 24] , _lowercase : str=7 , _lowercase : Union[str, Any]=4.0 , _lowercase : List[str]=True , _lowercase : List[Any]=0.0 , _lowercase : Dict=0.0 , _lowercase : List[Any]=0.1 , _lowercase : Union[str, Any]="gelu" , _lowercase : Tuple=False , _lowercase : Optional[int]=0.02 , _lowercase : List[Any]=1E-5 , _lowercase : Tuple=32 , **_lowercase : Optional[int] , ): super().__init__(**_lowercase ) __UpperCAmelCase = image_size __UpperCAmelCase = patch_size __UpperCAmelCase = num_channels __UpperCAmelCase = embed_dim __UpperCAmelCase = depths __UpperCAmelCase = len(_lowercase ) __UpperCAmelCase = num_heads __UpperCAmelCase = window_size __UpperCAmelCase = mlp_ratio __UpperCAmelCase = qkv_bias __UpperCAmelCase = hidden_dropout_prob __UpperCAmelCase = attention_probs_dropout_prob __UpperCAmelCase = drop_path_rate __UpperCAmelCase = hidden_act __UpperCAmelCase = use_absolute_embeddings __UpperCAmelCase = layer_norm_eps __UpperCAmelCase = initializer_range __UpperCAmelCase = encoder_stride # we set the hidden_size attribute in order to make Swinv2 work with VisionEncoderDecoderModel # this indicates the channel dimension after the last stage of the model __UpperCAmelCase = int(embed_dim * 2 ** (len(_lowercase ) - 1) ) __UpperCAmelCase = (0, 0, 0, 0)
332
1
"""simple docstring""" 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 _UpperCAmelCase ( unittest.TestCase ): def a ( self : Any , _lowercase : Union[str, Any] , _lowercase : Union[str, Any] ): return F'''gaussian_noise_s={seed}_shape={"_".join([str(_lowercase ) for s in shape] )}.npy''' def a ( self : Any ): # clean up the VRAM after each test super().tearDown() gc.collect() def a ( self : Optional[int] , _lowercase : Optional[Any]=0 , _lowercase : List[Any]=(4, 4, 64, 64) , _lowercase : List[Any]=False ): __UpperCAmelCase = jnp.bfloataa if fpaa else jnp.floataa __UpperCAmelCase = jnp.array(load_hf_numpy(self.get_file_format(_lowercase , _lowercase ) ) , dtype=_lowercase ) return image def a ( self : Dict , _lowercase : List[Any]=False , _lowercase : Union[str, Any]="CompVis/stable-diffusion-v1-4" ): __UpperCAmelCase = jnp.bfloataa if fpaa else jnp.floataa __UpperCAmelCase = '''bf16''' if fpaa else None __UpperCAmelCase , __UpperCAmelCase = FlaxUNetaDConditionModel.from_pretrained( _lowercase , subfolder='''unet''' , dtype=_lowercase , revision=_lowercase ) return model, params def a ( self : int , _lowercase : Optional[Any]=0 , _lowercase : Any=(4, 77, 7_68) , _lowercase : List[str]=False ): __UpperCAmelCase = jnp.bfloataa if fpaa else jnp.floataa __UpperCAmelCase = jnp.array(load_hf_numpy(self.get_file_format(_lowercase , _lowercase ) ) , dtype=_lowercase ) return hidden_states @parameterized.expand( [ # fmt: off [83, 4, [-0.2_323, -0.1_304, 0.0_813, -0.3_093, -0.0_919, -0.1_571, -0.1_125, -0.5_806]], [17, 0.55, [-0.0_831, -0.2_443, 0.0_901, -0.0_919, 0.3_396, 0.0_103, -0.3_743, 0.0_701]], [8, 0.89, [-0.4_863, 0.0_859, 0.0_875, -0.1_658, 0.9_199, -0.0_114, 0.4_839, 0.4_639]], [3, 10_00, [-0.5_649, 0.2_402, -0.5_518, 0.1_248, 1.1_328, -0.2_443, -0.0_325, -1.0_078]], # fmt: on ] ) def a ( self : List[str] , _lowercase : List[Any] , _lowercase : List[Any] , _lowercase : Tuple ): __UpperCAmelCase , __UpperCAmelCase = self.get_unet_model(model_id='''CompVis/stable-diffusion-v1-4''' , fpaa=_lowercase ) __UpperCAmelCase = self.get_latents(_lowercase , fpaa=_lowercase ) __UpperCAmelCase = self.get_encoder_hidden_states(_lowercase , fpaa=_lowercase ) __UpperCAmelCase = model.apply( {'''params''': params} , _lowercase , jnp.array(_lowercase , dtype=jnp.intaa ) , encoder_hidden_states=_lowercase , ).sample assert sample.shape == latents.shape __UpperCAmelCase = jnp.asarray(jax.device_get((sample[-1, -2:, -2:, :2].flatten()) ) , dtype=jnp.floataa ) __UpperCAmelCase = jnp.array(_lowercase , dtype=jnp.floataa ) # Found torch (float16) and flax (bfloat16) outputs to be within this tolerance, in the same hardware assert jnp.allclose(_lowercase , _lowercase , atol=1E-2 ) @parameterized.expand( [ # fmt: off [83, 4, [0.1_514, 0.0_807, 0.1_624, 0.1_016, -0.1_896, 0.0_263, 0.0_677, 0.2_310]], [17, 0.55, [0.1_164, -0.0_216, 0.0_170, 0.1_589, -0.3_120, 0.1_005, -0.0_581, -0.1_458]], [8, 0.89, [-0.1_758, -0.0_169, 0.1_004, -0.1_411, 0.1_312, 0.1_103, -0.1_996, 0.2_139]], [3, 10_00, [0.1_214, 0.0_352, -0.0_731, -0.1_562, -0.0_994, -0.0_906, -0.2_340, -0.0_539]], # fmt: on ] ) def a ( self : Dict , _lowercase : List[Any] , _lowercase : Union[str, Any] , _lowercase : Union[str, Any] ): __UpperCAmelCase , __UpperCAmelCase = self.get_unet_model(model_id='''stabilityai/stable-diffusion-2''' , fpaa=_lowercase ) __UpperCAmelCase = self.get_latents(_lowercase , shape=(4, 4, 96, 96) , fpaa=_lowercase ) __UpperCAmelCase = self.get_encoder_hidden_states(_lowercase , shape=(4, 77, 10_24) , fpaa=_lowercase ) __UpperCAmelCase = model.apply( {'''params''': params} , _lowercase , jnp.array(_lowercase , dtype=jnp.intaa ) , encoder_hidden_states=_lowercase , ).sample assert sample.shape == latents.shape __UpperCAmelCase = jnp.asarray(jax.device_get((sample[-1, -2:, -2:, :2].flatten()) ) , dtype=jnp.floataa ) __UpperCAmelCase = jnp.array(_lowercase , dtype=jnp.floataa ) # Found torch (float16) and flax (bfloat16) outputs to be within this tolerance, on the same hardware assert jnp.allclose(_lowercase , _lowercase , atol=1E-2 )
332
"""simple docstring""" import pprint import requests _lowercase : Optional[Any] = 'https://zenquotes.io/api' def lowercase__ ( ): return requests.get(API_ENDPOINT_URL + '''/today''' ).json() def lowercase__ ( ): return requests.get(API_ENDPOINT_URL + '''/random''' ).json() if __name__ == "__main__": _lowercase : int = random_quotes() pprint.pprint(response)
332
1
"""simple docstring""" class _UpperCAmelCase ( _lowerCAmelCase ): pass class _UpperCAmelCase ( _lowerCAmelCase ): pass class _UpperCAmelCase : def __init__( self : Any ): __UpperCAmelCase = [ [], [], [], ] def a ( self : Tuple , _lowercase : int , _lowercase : int ): try: if len(self.queues[priority] ) >= 1_00: raise OverflowError('''Maximum queue size is 100''' ) self.queues[priority].append(_lowercase ) except IndexError: raise ValueError('''Valid priorities are 0, 1, and 2''' ) def a ( self : Optional[Any] ): for queue in self.queues: if queue: return queue.pop(0 ) raise UnderFlowError('''All queues are empty''' ) def __str__( self : Optional[Any] ): return "\n".join(F'''Priority {i}: {q}''' for i, q in enumerate(self.queues ) ) class _UpperCAmelCase : def __init__( self : int ): __UpperCAmelCase = [] def a ( self : Dict , _lowercase : int ): if len(self.queue ) == 1_00: raise OverFlowError('''Maximum queue size is 100''' ) self.queue.append(_lowercase ) def a ( self : Optional[int] ): if not self.queue: raise UnderFlowError('''The queue is empty''' ) else: __UpperCAmelCase = min(self.queue ) self.queue.remove(_lowercase ) return data def __str__( self : List[str] ): return str(self.queue ) def lowercase__ ( ): __UpperCAmelCase = FixedPriorityQueue() fpq.enqueue(0 , 10 ) fpq.enqueue(1 , 70 ) fpq.enqueue(0 , 100 ) fpq.enqueue(2 , 1 ) fpq.enqueue(2 , 5 ) fpq.enqueue(1 , 7 ) fpq.enqueue(2 , 4 ) fpq.enqueue(1 , 64 ) fpq.enqueue(0 , 128 ) print(snake_case_ ) print(fpq.dequeue() ) print(fpq.dequeue() ) print(fpq.dequeue() ) print(fpq.dequeue() ) print(fpq.dequeue() ) print(snake_case_ ) print(fpq.dequeue() ) print(fpq.dequeue() ) print(fpq.dequeue() ) print(fpq.dequeue() ) print(fpq.dequeue() ) def lowercase__ ( ): __UpperCAmelCase = ElementPriorityQueue() epq.enqueue(10 ) epq.enqueue(70 ) epq.enqueue(100 ) epq.enqueue(1 ) epq.enqueue(5 ) epq.enqueue(7 ) epq.enqueue(4 ) epq.enqueue(64 ) epq.enqueue(128 ) print(snake_case_ ) print(epq.dequeue() ) print(epq.dequeue() ) print(epq.dequeue() ) print(epq.dequeue() ) print(epq.dequeue() ) print(snake_case_ ) print(epq.dequeue() ) print(epq.dequeue() ) print(epq.dequeue() ) print(epq.dequeue() ) print(epq.dequeue() ) if __name__ == "__main__": fixed_priority_queue() element_priority_queue()
332
"""simple docstring""" from typing import List, Optional, Union import numpy as np import tensorflow as tf from .utils import logging _lowercase : List[str] = logging.get_logger(__name__) def lowercase__ ( snake_case_ :Union[tf.Tensor, np.ndarray] ): if isinstance(snake_case_ , np.ndarray ): return list(tensor.shape ) __UpperCAmelCase = tf.shape(snake_case_ ) if tensor.shape == tf.TensorShape(snake_case_ ): return dynamic __UpperCAmelCase = tensor.shape.as_list() return [dynamic[i] if s is None else s for i, s in enumerate(snake_case_ )] def lowercase__ ( snake_case_ :tf.Tensor , snake_case_ :Optional[int] = None , snake_case_ :Optional[str] = None ): return tf.nn.softmax(logits=logits + 1E-9 , axis=snake_case_ , name=snake_case_ ) def lowercase__ ( snake_case_ :int , snake_case_ :Union[str, Any] , snake_case_ :str , snake_case_ :Union[str, Any]=1E-5 , snake_case_ :List[str]=-1 ): # This is a very simplified functional layernorm, designed to duplicate # the functionality of PyTorch nn.functional.layer_norm when this is needed to port # models in Transformers. if weight.shape.rank != 1 or bias.shape.rank != 1 or not isinstance(snake_case_ , snake_case_ ): raise NotImplementedError('''Only 1D weight and bias tensors are supported for now, with only a single axis.''' ) # Get mean and variance on the axis to be normalized __UpperCAmelCase , __UpperCAmelCase = tf.nn.moments(snake_case_ , axes=[axis] , keepdims=snake_case_ ) if axis != -1: # Reshape scale and weight to have the same rank as inputs, but with 1 dimensions # on every dimension except axis __UpperCAmelCase = [1] * inputs.shape.rank __UpperCAmelCase = shape_list(snake_case_ )[axis] __UpperCAmelCase = tf.reshape(snake_case_ , snake_case_ ) __UpperCAmelCase = tf.reshape(snake_case_ , snake_case_ ) # Compute layer normalization using the batch_normalization # function. __UpperCAmelCase = tf.nn.batch_normalization( snake_case_ , snake_case_ , snake_case_ , offset=snake_case_ , scale=snake_case_ , variance_epsilon=snake_case_ , ) return outputs def lowercase__ ( snake_case_ :Optional[int] , snake_case_ :List[str]=0 , snake_case_ :Optional[Any]=-1 ): # Replicates the behavior of torch.flatten in TF # If end_dim or start_dim is negative, count them from the end if end_dim < 0: end_dim += input.shape.rank if start_dim < 0: start_dim += input.shape.rank if start_dim == end_dim: return input __UpperCAmelCase = tf.shape(snake_case_ ) __UpperCAmelCase = tf.math.reduce_prod(in_shape[start_dim : end_dim + 1] ) __UpperCAmelCase = tf.concat([in_shape[:start_dim], [flattened_dim], in_shape[end_dim + 1 :]] , axis=0 ) return tf.reshape(snake_case_ , snake_case_ ) def lowercase__ ( snake_case_ :tf.Tensor ): if not isinstance(snake_case_ , tf.Tensor ): __UpperCAmelCase = tf.convert_to_tensor(snake_case_ ) # Catches stray NumPy inputs if encoder_attention_mask.shape.rank == 3: __UpperCAmelCase = encoder_attention_mask[:, None, :, :] if encoder_attention_mask.shape.rank == 2: __UpperCAmelCase = encoder_attention_mask[:, None, None, :] # T5 has a mask that can compare sequence ids, we can simulate this here with this transposition # Cf. https://github.com/tensorflow/mesh/blob/8d2465e9bc93129b913b5ccc6a59aa97abd96ec6/mesh_tensorflow # /transformer/transformer_layers.py#L270 # encoder_extended_attention_mask = (encoder_extended_attention_mask == # encoder_extended_attention_mask.transpose(-1, -2)) __UpperCAmelCase = ( tf.cast(1 , encoder_attention_mask.dtype ) - encoder_extended_attention_mask ) * encoder_extended_attention_mask.dtype.min return encoder_extended_attention_mask def lowercase__ ( snake_case_ :tf.Tensor , snake_case_ :int , snake_case_ :str = "input_ids" ): tf.debugging.assert_less( snake_case_ , tf.cast(snake_case_ , dtype=tensor.dtype ) , message=( F'''The maximum value of {tensor_name} ({tf.math.reduce_max(snake_case_ )}) must be smaller than the embedding ''' F'''layer\'s input dimension ({embed_dim}). The likely cause is some problem at tokenization time.''' ) , ) def lowercase__ ( snake_case_ :List[Any] , snake_case_ :List[Any] , snake_case_ :List[str] ): __UpperCAmelCase = 64_512 # Check that no item in `data` is larger than `HDF5_OBJECT_HEADER_LIMIT` # because in that case even chunking the array would not make the saving # possible. __UpperCAmelCase = [x for x in data if len(snake_case_ ) > HDF5_OBJECT_HEADER_LIMIT] # Expecting this to never be true. if bad_attributes: raise RuntimeError( '''The following attributes cannot be saved to HDF5 file because ''' F'''they are larger than {HDF5_OBJECT_HEADER_LIMIT} ''' F'''bytes: {bad_attributes}''' ) __UpperCAmelCase = np.asarray(snake_case_ ) __UpperCAmelCase = 1 __UpperCAmelCase = np.array_split(snake_case_ , snake_case_ ) # This will never loop forever thanks to the test above. while any(x.nbytes > HDF5_OBJECT_HEADER_LIMIT for x in chunked_data ): num_chunks += 1 __UpperCAmelCase = np.array_split(snake_case_ , snake_case_ ) if num_chunks > 1: for chunk_id, chunk_data in enumerate(snake_case_ ): __UpperCAmelCase = chunk_data else: __UpperCAmelCase = data def lowercase__ ( snake_case_ :str , snake_case_ :List[str] ): if name in group.attrs: __UpperCAmelCase = [n.decode('''utf8''' ) if hasattr(snake_case_ , '''decode''' ) else n for n in group.attrs[name]] else: __UpperCAmelCase = [] __UpperCAmelCase = 0 while "%s%d" % (name, chunk_id) in group.attrs: data.extend( [n.decode('''utf8''' ) if hasattr(snake_case_ , '''decode''' ) else n for n in group.attrs['''%s%d''' % (name, chunk_id)]] ) chunk_id += 1 return data def lowercase__ ( snake_case_ :Tuple ): def _expand_single_ad_tensor(snake_case_ :Optional[int] ): if isinstance(snake_case_ , tf.Tensor ) and t.shape.rank == 1: return tf.expand_dims(snake_case_ , axis=-1 ) return t return tf.nest.map_structure(_expand_single_ad_tensor , snake_case_ )
332
1
"""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 lowercase__ ( snake_case_ :Union[str, Any]=None ): if subparsers is not None: __UpperCAmelCase = subparsers.add_parser('''env''' ) else: __UpperCAmelCase = argparse.ArgumentParser('''Accelerate env command''' ) parser.add_argument( '''--config_file''' , default=snake_case_ , help='''The config file to use for the default values in the launching script.''' ) if subparsers is not None: parser.set_defaults(func=snake_case_ ) return parser def lowercase__ ( snake_case_ :List[Any] ): __UpperCAmelCase = torch.__version__ __UpperCAmelCase = torch.cuda.is_available() __UpperCAmelCase = is_xpu_available() __UpperCAmelCase = is_npu_available() __UpperCAmelCase = '''Not found''' # Get the default from the config file. if args.config_file is not None or os.path.isfile(snake_case_ ): __UpperCAmelCase = load_config_from_file(args.config_file ).to_dict() __UpperCAmelCase = { '''`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(snake_case_ ), '''PyTorch NPU available''': str(snake_case_ ), '''System RAM''': F'''{psutil.virtual_memory().total / 1_024 ** 3:.2f} GB''', } if pt_cuda_available: __UpperCAmelCase = 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 = ( '''\n'''.join([F'''\t- {prop}: {val}''' for prop, val in accelerate_config.items()] ) if isinstance(snake_case_ , snake_case_ ) else F'''\t{accelerate_config}''' ) print(snake_case_ ) __UpperCAmelCase = accelerate_config return info def lowercase__ ( ): __UpperCAmelCase = env_command_parser() __UpperCAmelCase = parser.parse_args() env_command(snake_case_ ) return 0 if __name__ == "__main__": raise SystemExit(main())
332
"""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 lowercase__ ( snake_case_ :Union[str, Any]=None ): if subparsers is not None: __UpperCAmelCase = subparsers.add_parser('''env''' ) else: __UpperCAmelCase = argparse.ArgumentParser('''Accelerate env command''' ) parser.add_argument( '''--config_file''' , default=snake_case_ , help='''The config file to use for the default values in the launching script.''' ) if subparsers is not None: parser.set_defaults(func=snake_case_ ) return parser def lowercase__ ( snake_case_ :List[Any] ): __UpperCAmelCase = torch.__version__ __UpperCAmelCase = torch.cuda.is_available() __UpperCAmelCase = is_xpu_available() __UpperCAmelCase = is_npu_available() __UpperCAmelCase = '''Not found''' # Get the default from the config file. if args.config_file is not None or os.path.isfile(snake_case_ ): __UpperCAmelCase = load_config_from_file(args.config_file ).to_dict() __UpperCAmelCase = { '''`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(snake_case_ ), '''PyTorch NPU available''': str(snake_case_ ), '''System RAM''': F'''{psutil.virtual_memory().total / 1_024 ** 3:.2f} GB''', } if pt_cuda_available: __UpperCAmelCase = 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 = ( '''\n'''.join([F'''\t- {prop}: {val}''' for prop, val in accelerate_config.items()] ) if isinstance(snake_case_ , snake_case_ ) else F'''\t{accelerate_config}''' ) print(snake_case_ ) __UpperCAmelCase = accelerate_config return info def lowercase__ ( ): __UpperCAmelCase = env_command_parser() __UpperCAmelCase = parser.parse_args() env_command(snake_case_ ) return 0 if __name__ == "__main__": raise SystemExit(main())
332
1
"""simple docstring""" from typing import List import numpy as np def lowercase__ ( snake_case_ :dict ): __UpperCAmelCase = {key: len(snake_case_ ) for key, value in gen_kwargs.items() if isinstance(snake_case_ , snake_case_ )} if len(set(lists_lengths.values() ) ) > 1: raise RuntimeError( ( '''Sharding is ambiguous for this dataset: ''' + '''we found several data sources lists of different lengths, and we don\'t know over which list we should parallelize:\n''' + '''\n'''.join(F'''\t- key {key} has length {length}''' for key, length in lists_lengths.items() ) + '''\nTo fix this, check the \'gen_kwargs\' and make sure to use lists only for data sources, ''' + '''and use tuples otherwise. In the end there should only be one single list, or several lists with the same length.''' ) ) __UpperCAmelCase = max(lists_lengths.values() , default=0 ) return max(1 , snake_case_ ) def lowercase__ ( snake_case_ :int , snake_case_ :int ): __UpperCAmelCase = [] for group_idx in range(snake_case_ ): __UpperCAmelCase = num_shards // max_num_jobs + (group_idx < (num_shards % max_num_jobs)) if num_shards_to_add == 0: break __UpperCAmelCase = shards_indices_per_group[-1].stop if shards_indices_per_group else 0 __UpperCAmelCase = range(snake_case_ , start + num_shards_to_add ) shards_indices_per_group.append(snake_case_ ) return shards_indices_per_group def lowercase__ ( snake_case_ :dict , snake_case_ :int ): __UpperCAmelCase = _number_of_shards_in_gen_kwargs(snake_case_ ) if num_shards == 1: return [dict(snake_case_ )] else: __UpperCAmelCase = _distribute_shards(num_shards=snake_case_ , max_num_jobs=snake_case_ ) return [ { key: [value[shard_idx] for shard_idx in shard_indices_per_group[group_idx]] if isinstance(snake_case_ , snake_case_ ) else value for key, value in gen_kwargs.items() } for group_idx in range(len(snake_case_ ) ) ] def lowercase__ ( snake_case_ :List[dict] ): return { key: [value for gen_kwargs in gen_kwargs_list for value in gen_kwargs[key]] if isinstance(gen_kwargs_list[0][key] , snake_case_ ) else gen_kwargs_list[0][key] for key in gen_kwargs_list[0] } def lowercase__ ( snake_case_ :np.random.Generator , snake_case_ :dict ): __UpperCAmelCase = {len(snake_case_ ) for value in gen_kwargs.values() if isinstance(snake_case_ , snake_case_ )} __UpperCAmelCase = {} for size in list_sizes: __UpperCAmelCase = list(range(snake_case_ ) ) rng.shuffle(indices_per_size[size] ) # Now let's copy the gen_kwargs and shuffle the lists based on their sizes __UpperCAmelCase = dict(snake_case_ ) for key, value in shuffled_kwargs.items(): if isinstance(snake_case_ , snake_case_ ): __UpperCAmelCase = [value[i] for i in indices_per_size[len(snake_case_ )]] return shuffled_kwargs
332
"""simple docstring""" import shutil import tempfile import unittest from transformers import SPIECE_UNDERLINE, BatchEncoding, MBartaaTokenizer, MBartaaTokenizerFast, is_torch_available from transformers.testing_utils import ( get_tests_dir, nested_simplify, require_sentencepiece, require_tokenizers, require_torch, slow, ) from ...test_tokenization_common import TokenizerTesterMixin _lowercase : Tuple = get_tests_dir('fixtures/test_sentencepiece.model') if is_torch_available(): from transformers.models.mbart.modeling_mbart import shift_tokens_right _lowercase : List[str] = 25_00_04 _lowercase : int = 25_00_20 @require_sentencepiece @require_tokenizers class _UpperCAmelCase ( _lowerCAmelCase , unittest.TestCase ): a__ : Union[str, Any] = MBartaaTokenizer a__ : List[str] = MBartaaTokenizerFast a__ : Any = True a__ : List[str] = True def a ( self : str ): super().setUp() # We have a SentencePiece fixture for testing __UpperCAmelCase = MBartaaTokenizer(_lowercase , src_lang='''en_XX''' , tgt_lang='''ro_RO''' , keep_accents=_lowercase ) tokenizer.save_pretrained(self.tmpdirname ) def a ( self : Dict ): __UpperCAmelCase = '''<s>''' __UpperCAmelCase = 0 self.assertEqual(self.get_tokenizer()._convert_token_to_id(_lowercase ) , _lowercase ) self.assertEqual(self.get_tokenizer()._convert_id_to_token(_lowercase ) , _lowercase ) def a ( self : Optional[Any] ): __UpperCAmelCase = list(self.get_tokenizer().get_vocab().keys() ) self.assertEqual(vocab_keys[0] , '''<s>''' ) self.assertEqual(vocab_keys[1] , '''<pad>''' ) self.assertEqual(vocab_keys[-1] , '''<mask>''' ) self.assertEqual(len(_lowercase ) , 10_54 ) def a ( self : Tuple ): self.assertEqual(self.get_tokenizer().vocab_size , 10_54 ) def a ( self : str ): __UpperCAmelCase = MBartaaTokenizer(_lowercase , src_lang='''en_XX''' , tgt_lang='''ro_RO''' , keep_accents=_lowercase ) __UpperCAmelCase = tokenizer.tokenize('''This is a test''' ) self.assertListEqual(_lowercase , ['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est'''] ) self.assertListEqual( tokenizer.convert_tokens_to_ids(_lowercase ) , [value + tokenizer.fairseq_offset for value in [2_85, 46, 10, 1_70, 3_82]] , ) __UpperCAmelCase = tokenizer.tokenize('''I was born in 92000, and this is falsé.''' ) self.assertListEqual( _lowercase , [SPIECE_UNDERLINE + '''I''', SPIECE_UNDERLINE + '''was''', SPIECE_UNDERLINE + '''b''', '''or''', '''n''', SPIECE_UNDERLINE + '''in''', SPIECE_UNDERLINE + '''''', '''9''', '''2''', '''0''', '''0''', '''0''', ''',''', SPIECE_UNDERLINE + '''and''', SPIECE_UNDERLINE + '''this''', SPIECE_UNDERLINE + '''is''', SPIECE_UNDERLINE + '''f''', '''al''', '''s''', '''é''', '''.'''] , ) __UpperCAmelCase = tokenizer.convert_tokens_to_ids(_lowercase ) self.assertListEqual( _lowercase , [ value + tokenizer.fairseq_offset for value in [8, 21, 84, 55, 24, 19, 7, 2, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 2, 4] ] , ) __UpperCAmelCase = tokenizer.convert_ids_to_tokens(_lowercase ) self.assertListEqual( _lowercase , [SPIECE_UNDERLINE + '''I''', SPIECE_UNDERLINE + '''was''', SPIECE_UNDERLINE + '''b''', '''or''', '''n''', SPIECE_UNDERLINE + '''in''', SPIECE_UNDERLINE + '''''', '''<unk>''', '''2''', '''0''', '''0''', '''0''', ''',''', SPIECE_UNDERLINE + '''and''', SPIECE_UNDERLINE + '''this''', SPIECE_UNDERLINE + '''is''', SPIECE_UNDERLINE + '''f''', '''al''', '''s''', '''<unk>''', '''.'''] , ) @slow def a ( self : str ): # fmt: off __UpperCAmelCase = {'''input_ids''': [[25_00_04, 1_10_62, 8_27_72, 7, 15, 8_27_72, 5_38, 5_15_29, 2_37, 1_71_98, 12_90, 2_06, 9, 21_51_75, 13_14, 1_36, 1_71_98, 12_90, 2_06, 9, 5_63_59, 42, 12_20_09, 9, 1_64_66, 16, 8_73_44, 45_37, 9, 47_17, 7_83_81, 6, 15_99_58, 7, 15, 2_44_80, 6_18, 4, 5_27, 2_26_93, 54_28, 4, 27_77, 2_44_80, 98_74, 4, 4_35_23, 5_94, 4, 8_03, 1_83_92, 3_31_89, 18, 4, 4_35_23, 2_44_47, 1_23_99, 1_00, 2_49_55, 8_36_58, 96_26, 14_40_57, 15, 8_39, 2_23_35, 16, 1_36, 2_49_55, 8_36_58, 8_34_79, 15, 3_91_02, 7_24, 16, 6_78, 6_45, 27_89, 13_28, 45_89, 42, 12_20_09, 11_57_74, 23, 8_05, 13_28, 4_68_76, 7, 1_36, 5_38_94, 19_40, 4_22_27, 4_11_59, 1_77_21, 8_23, 4_25, 4, 2_75_12, 9_87_22, 2_06, 1_36, 55_31, 49_70, 9_19, 1_73_36, 5, 2], [25_00_04, 2_00_80, 6_18, 83, 8_27_75, 47, 4_79, 9, 15_17, 73, 5_38_94, 3_33, 8_05_81, 11_01_17, 1_88_11, 52_56, 12_95, 51, 15_25_26, 2_97, 79_86, 3_90, 12_44_16, 5_38, 3_54_31, 2_14, 98, 1_50_44, 2_57_37, 1_36, 71_08, 4_37_01, 23, 7_56, 13_53_55, 7, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [25_00_04, 5_81, 6_37_73, 11_94_55, 6, 14_77_97, 8_82_03, 7, 6_45, 70, 21, 32_85, 1_02_69, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], '''attention_mask''': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]} # noqa: E501 # fmt: on self.tokenizer_integration_test_util( expected_encoding=_lowercase , model_name='''facebook/mbart-large-50''' , revision='''d3913889c59cd5c9e456b269c376325eabad57e2''' , ) def a ( self : 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 __UpperCAmelCase = (self.rust_tokenizer_class, '''hf-internal-testing/tiny-random-mbart50''', {}) for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})''' ): __UpperCAmelCase = self.rust_tokenizer_class.from_pretrained(_lowercase , **_lowercase ) __UpperCAmelCase = self.tokenizer_class.from_pretrained(_lowercase , **_lowercase ) __UpperCAmelCase = tempfile.mkdtemp() __UpperCAmelCase = tokenizer_r.save_pretrained(_lowercase ) __UpperCAmelCase = tokenizer_p.save_pretrained(_lowercase ) # Checks it save with the same files + the tokenizer.json file for the fast one self.assertTrue(any('''tokenizer.json''' in f for f in tokenizer_r_files ) ) __UpperCAmelCase = tuple(f for f in tokenizer_r_files if '''tokenizer.json''' not in f ) self.assertSequenceEqual(_lowercase , _lowercase ) # Checks everything loads correctly in the same way __UpperCAmelCase = tokenizer_r.from_pretrained(_lowercase ) __UpperCAmelCase = tokenizer_p.from_pretrained(_lowercase ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(_lowercase , _lowercase ) ) # self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key)) # self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id")) shutil.rmtree(_lowercase ) # Save tokenizer rust, legacy_format=True __UpperCAmelCase = tempfile.mkdtemp() __UpperCAmelCase = tokenizer_r.save_pretrained(_lowercase , legacy_format=_lowercase ) __UpperCAmelCase = tokenizer_p.save_pretrained(_lowercase ) # Checks it save with the same files self.assertSequenceEqual(_lowercase , _lowercase ) # Checks everything loads correctly in the same way __UpperCAmelCase = tokenizer_r.from_pretrained(_lowercase ) __UpperCAmelCase = tokenizer_p.from_pretrained(_lowercase ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(_lowercase , _lowercase ) ) shutil.rmtree(_lowercase ) # Save tokenizer rust, legacy_format=False __UpperCAmelCase = tempfile.mkdtemp() __UpperCAmelCase = tokenizer_r.save_pretrained(_lowercase , legacy_format=_lowercase ) __UpperCAmelCase = tokenizer_p.save_pretrained(_lowercase ) # Checks it saved the tokenizer.json file self.assertTrue(any('''tokenizer.json''' in f for f in tokenizer_r_files ) ) # Checks everything loads correctly in the same way __UpperCAmelCase = tokenizer_r.from_pretrained(_lowercase ) __UpperCAmelCase = tokenizer_p.from_pretrained(_lowercase ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(_lowercase , _lowercase ) ) shutil.rmtree(_lowercase ) @require_torch @require_sentencepiece @require_tokenizers class _UpperCAmelCase ( unittest.TestCase ): a__ : str = "facebook/mbart-large-50-one-to-many-mmt" a__ : Union[str, Any] = [ " UN Chief Says There Is No Military Solution in Syria", " Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.", ] a__ : Any = [ "Şeful ONU declară că nu există o soluţie militară în Siria", "Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei" " pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor" " face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.", ] a__ : Any = [EN_CODE, 8_274, 127_873, 25_916, 7, 8_622, 2_071, 438, 67_485, 53, 187_895, 23, 51_712, 2] @classmethod def a ( cls : Tuple ): __UpperCAmelCase = MBartaaTokenizer.from_pretrained( cls.checkpoint_name , src_lang='''en_XX''' , tgt_lang='''ro_RO''' ) __UpperCAmelCase = 1 return cls def a ( self : Union[str, Any] ): self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ar_AR'''] , 25_00_01 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''en_EN'''] , 25_00_04 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ro_RO'''] , 25_00_20 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''mr_IN'''] , 25_00_38 ) def a ( self : Union[str, Any] ): __UpperCAmelCase = self.tokenizer.batch_encode_plus(self.src_text ).input_ids[0] self.assertListEqual(self.expected_src_tokens , _lowercase ) def a ( self : Optional[Any] ): self.assertIn(_lowercase , self.tokenizer.all_special_ids ) __UpperCAmelCase = [RO_CODE, 8_84, 90_19, 96, 9, 9_16, 8_67_92, 36, 1_87_43, 1_55_96, 5, 2] __UpperCAmelCase = self.tokenizer.decode(_lowercase , skip_special_tokens=_lowercase ) __UpperCAmelCase = self.tokenizer.decode(generated_ids[1:] , skip_special_tokens=_lowercase ) self.assertEqual(_lowercase , _lowercase ) self.assertNotIn(self.tokenizer.eos_token , _lowercase ) def a ( self : Optional[Any] ): __UpperCAmelCase = ['''this is gunna be a long sentence ''' * 20] assert isinstance(src_text[0] , _lowercase ) __UpperCAmelCase = 10 __UpperCAmelCase = self.tokenizer(_lowercase , max_length=_lowercase , truncation=_lowercase ).input_ids[0] self.assertEqual(ids[0] , _lowercase ) self.assertEqual(ids[-1] , 2 ) self.assertEqual(len(_lowercase ) , _lowercase ) def a ( self : Optional[int] ): self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['''<mask>''', '''ar_AR'''] ) , [25_00_53, 25_00_01] ) def a ( self : Union[str, Any] ): __UpperCAmelCase = tempfile.mkdtemp() __UpperCAmelCase = self.tokenizer.fairseq_tokens_to_ids self.tokenizer.save_pretrained(_lowercase ) __UpperCAmelCase = MBartaaTokenizer.from_pretrained(_lowercase ) self.assertDictEqual(new_tok.fairseq_tokens_to_ids , _lowercase ) @require_torch def a ( self : Dict ): __UpperCAmelCase = self.tokenizer(self.src_text , text_target=self.tgt_text , padding=_lowercase , return_tensors='''pt''' ) __UpperCAmelCase = shift_tokens_right(batch['''labels'''] , self.tokenizer.pad_token_id ) # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4 assert batch.input_ids[1][0] == EN_CODE assert batch.input_ids[1][-1] == 2 assert batch.labels[1][0] == RO_CODE assert batch.labels[1][-1] == 2 assert batch.decoder_input_ids[1][:2].tolist() == [2, RO_CODE] @require_torch def a ( self : Union[str, Any] ): __UpperCAmelCase = self.tokenizer( self.src_text , text_target=self.tgt_text , padding=_lowercase , truncation=_lowercase , max_length=len(self.expected_src_tokens ) , return_tensors='''pt''' , ) __UpperCAmelCase = shift_tokens_right(batch['''labels'''] , self.tokenizer.pad_token_id ) self.assertIsInstance(_lowercase , _lowercase ) self.assertEqual((2, 14) , batch.input_ids.shape ) self.assertEqual((2, 14) , batch.attention_mask.shape ) __UpperCAmelCase = batch.input_ids.tolist()[0] self.assertListEqual(self.expected_src_tokens , _lowercase ) self.assertEqual(2 , batch.decoder_input_ids[0, 0] ) # decoder_start_token_id # Test that special tokens are reset self.assertEqual(self.tokenizer.prefix_tokens , [EN_CODE] ) self.assertEqual(self.tokenizer.suffix_tokens , [self.tokenizer.eos_token_id] ) def a ( self : Union[str, Any] ): __UpperCAmelCase = self.tokenizer(self.src_text , padding=_lowercase , truncation=_lowercase , max_length=3 , return_tensors='''pt''' ) __UpperCAmelCase = self.tokenizer( text_target=self.tgt_text , padding=_lowercase , truncation=_lowercase , max_length=10 , return_tensors='''pt''' ) __UpperCAmelCase = targets['''input_ids'''] __UpperCAmelCase = shift_tokens_right(_lowercase , self.tokenizer.pad_token_id ) self.assertEqual(batch.input_ids.shape[1] , 3 ) self.assertEqual(batch.decoder_input_ids.shape[1] , 10 ) @require_torch def a ( self : Dict ): __UpperCAmelCase = self.tokenizer._build_translation_inputs( '''A test''' , return_tensors='''pt''' , src_lang='''en_XX''' , tgt_lang='''ar_AR''' ) self.assertEqual( nested_simplify(_lowercase ) , { # en_XX, A, test, EOS '''input_ids''': [[25_00_04, 62, 30_34, 2]], '''attention_mask''': [[1, 1, 1, 1]], # ar_AR '''forced_bos_token_id''': 25_00_01, } , )
332
1
"""simple docstring""" import math from typing import Dict, Iterable, List, Optional, Tuple, Union import numpy as np from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict from ...image_transforms import normalize, rescale, resize, to_channel_dimension_format from ...image_utils import ( IMAGENET_STANDARD_MEAN, IMAGENET_STANDARD_STD, ChannelDimension, ImageInput, PILImageResampling, get_image_size, is_torch_available, is_torch_tensor, make_list_of_images, to_numpy_array, valid_images, ) from ...utils import TensorType, is_vision_available, logging if is_torch_available(): import torch if is_vision_available(): import PIL _lowercase : Optional[Any] = logging.get_logger(__name__) def lowercase__ ( snake_case_ :np.ndarray , snake_case_ :Union[int, Iterable[int]] , snake_case_ :bool , snake_case_ :int ): def constraint_to_multiple_of(snake_case_ :Tuple , snake_case_ :Union[str, Any] , snake_case_ :str=0 , snake_case_ :str=None ): __UpperCAmelCase = round(val / multiple ) * multiple if max_val is not None and x > max_val: __UpperCAmelCase = math.floor(val / multiple ) * multiple if x < min_val: __UpperCAmelCase = math.ceil(val / multiple ) * multiple return x __UpperCAmelCase = (output_size, output_size) if isinstance(snake_case_ , snake_case_ ) else output_size __UpperCAmelCase , __UpperCAmelCase = get_image_size(snake_case_ ) __UpperCAmelCase , __UpperCAmelCase = output_size # determine new height and width __UpperCAmelCase = output_height / input_height __UpperCAmelCase = output_width / input_width if keep_aspect_ratio: # scale as little as possible if abs(1 - scale_width ) < abs(1 - scale_height ): # fit width __UpperCAmelCase = scale_width else: # fit height __UpperCAmelCase = scale_height __UpperCAmelCase = constraint_to_multiple_of(scale_height * input_height , multiple=snake_case_ ) __UpperCAmelCase = constraint_to_multiple_of(scale_width * input_width , multiple=snake_case_ ) return (new_height, new_width) class _UpperCAmelCase ( _lowerCAmelCase ): a__ : Union[str, Any] = ["pixel_values"] def __init__( self : int , _lowercase : bool = True , _lowercase : Dict[str, int] = None , _lowercase : PILImageResampling = PILImageResampling.BILINEAR , _lowercase : bool = False , _lowercase : int = 1 , _lowercase : bool = True , _lowercase : Union[int, float] = 1 / 2_55 , _lowercase : bool = True , _lowercase : Optional[Union[float, List[float]]] = None , _lowercase : Optional[Union[float, List[float]]] = None , **_lowercase : Optional[Any] , ): super().__init__(**_lowercase ) __UpperCAmelCase = size if size is not None else {'''height''': 3_84, '''width''': 3_84} __UpperCAmelCase = get_size_dict(_lowercase ) __UpperCAmelCase = do_resize __UpperCAmelCase = size __UpperCAmelCase = keep_aspect_ratio __UpperCAmelCase = ensure_multiple_of __UpperCAmelCase = resample __UpperCAmelCase = do_rescale __UpperCAmelCase = rescale_factor __UpperCAmelCase = do_normalize __UpperCAmelCase = image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN __UpperCAmelCase = image_std if image_std is not None else IMAGENET_STANDARD_STD def a ( self : Optional[Any] , _lowercase : np.ndarray , _lowercase : Dict[str, int] , _lowercase : bool = False , _lowercase : int = 1 , _lowercase : PILImageResampling = PILImageResampling.BICUBIC , _lowercase : Optional[Union[str, ChannelDimension]] = None , **_lowercase : int , ): __UpperCAmelCase = get_size_dict(_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()}''' ) __UpperCAmelCase = get_resize_output_image_size( _lowercase , output_size=(size['''height'''], size['''width''']) , keep_aspect_ratio=_lowercase , multiple=_lowercase , ) return resize(_lowercase , size=_lowercase , resample=_lowercase , data_format=_lowercase , **_lowercase ) def a ( self : Union[str, Any] , _lowercase : np.ndarray , _lowercase : Union[int, float] , _lowercase : Optional[Union[str, ChannelDimension]] = None , **_lowercase : List[str] , ): return rescale(_lowercase , scale=_lowercase , data_format=_lowercase , **_lowercase ) def a ( self : Any , _lowercase : np.ndarray , _lowercase : Union[float, List[float]] , _lowercase : Union[float, List[float]] , _lowercase : Optional[Union[str, ChannelDimension]] = None , **_lowercase : Tuple , ): return normalize(_lowercase , mean=_lowercase , std=_lowercase , data_format=_lowercase , **_lowercase ) def a ( self : Tuple , _lowercase : ImageInput , _lowercase : bool = None , _lowercase : int = None , _lowercase : bool = None , _lowercase : int = None , _lowercase : PILImageResampling = None , _lowercase : bool = None , _lowercase : float = None , _lowercase : bool = None , _lowercase : Optional[Union[float, List[float]]] = None , _lowercase : Optional[Union[float, List[float]]] = None , _lowercase : Optional[Union[str, TensorType]] = None , _lowercase : ChannelDimension = ChannelDimension.FIRST , **_lowercase : Union[str, Any] , ): __UpperCAmelCase = do_resize if do_resize is not None else self.do_resize __UpperCAmelCase = size if size is not None else self.size __UpperCAmelCase = get_size_dict(_lowercase ) __UpperCAmelCase = keep_aspect_ratio if keep_aspect_ratio is not None else self.keep_aspect_ratio __UpperCAmelCase = ensure_multiple_of if ensure_multiple_of is not None else self.ensure_multiple_of __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 = 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.''' ) # All transformations expect numpy arrays. __UpperCAmelCase = [to_numpy_array(_lowercase ) for image in images] if do_resize: __UpperCAmelCase = [self.resize(image=_lowercase , size=_lowercase , resample=_lowercase ) for image in images] if do_rescale: __UpperCAmelCase = [self.rescale(image=_lowercase , scale=_lowercase ) for image in images] if do_normalize: __UpperCAmelCase = [self.normalize(image=_lowercase , mean=_lowercase , std=_lowercase ) for image in images] __UpperCAmelCase = [to_channel_dimension_format(_lowercase , _lowercase ) for image in images] __UpperCAmelCase = {'''pixel_values''': images} return BatchFeature(data=_lowercase , tensor_type=_lowercase ) def a ( self : Tuple , _lowercase : Dict , _lowercase : List[Tuple] = None ): __UpperCAmelCase = outputs.logits # Resize logits and compute semantic segmentation maps if target_sizes is not None: if len(_lowercase ) != len(_lowercase ): raise ValueError( '''Make sure that you pass in as many target sizes as the batch dimension of the logits''' ) if is_torch_tensor(_lowercase ): __UpperCAmelCase = target_sizes.numpy() __UpperCAmelCase = [] for idx in range(len(_lowercase ) ): __UpperCAmelCase = torch.nn.functional.interpolate( logits[idx].unsqueeze(dim=0 ) , size=target_sizes[idx] , mode='''bilinear''' , align_corners=_lowercase ) __UpperCAmelCase = resized_logits[0].argmax(dim=0 ) semantic_segmentation.append(_lowercase ) else: __UpperCAmelCase = logits.argmax(dim=1 ) __UpperCAmelCase = [semantic_segmentation[i] for i in range(semantic_segmentation.shape[0] )] return semantic_segmentation
332
"""simple docstring""" import unittest import torch from torch import nn from accelerate.test_utils import require_cuda from accelerate.utils.memory import find_executable_batch_size, release_memory def lowercase__ ( ): raise RuntimeError('''CUDA out of memory.''' ) class _UpperCAmelCase ( nn.Module ): def __init__( self : Optional[Any] ): super().__init__() __UpperCAmelCase = nn.Linear(3 , 4 ) __UpperCAmelCase = nn.BatchNormad(4 ) __UpperCAmelCase = nn.Linear(4 , 5 ) def a ( self : Optional[int] , _lowercase : Optional[Any] ): return self.lineara(self.batchnorm(self.lineara(_lowercase ) ) ) class _UpperCAmelCase ( unittest.TestCase ): def a ( self : List[str] ): __UpperCAmelCase = [] @find_executable_batch_size(starting_batch_size=1_28 ) def mock_training_loop_function(_lowercase : Optional[int] ): nonlocal batch_sizes batch_sizes.append(_lowercase ) if batch_size != 8: raise_fake_out_of_memory() mock_training_loop_function() self.assertListEqual(_lowercase , [1_28, 64, 32, 16, 8] ) def a ( self : Optional[int] ): __UpperCAmelCase = [] @find_executable_batch_size(starting_batch_size=1_28 ) def mock_training_loop_function(_lowercase : str , _lowercase : List[str] ): nonlocal batch_sizes batch_sizes.append(_lowercase ) if batch_size != 8: raise_fake_out_of_memory() return batch_size, arga __UpperCAmelCase , __UpperCAmelCase = mock_training_loop_function('''hello''' ) self.assertListEqual(_lowercase , [1_28, 64, 32, 16, 8] ) self.assertListEqual([bs, arga] , [8, '''hello'''] ) def a ( self : Tuple ): @find_executable_batch_size(starting_batch_size=0 ) def mock_training_loop_function(_lowercase : Optional[int] ): pass with self.assertRaises(_lowercase ) as cm: mock_training_loop_function() self.assertIn('''No executable batch size found, reached zero.''' , cm.exception.args[0] ) def a ( self : List[Any] ): @find_executable_batch_size(starting_batch_size=16 ) def mock_training_loop_function(_lowercase : List[Any] ): if batch_size > 0: raise_fake_out_of_memory() pass with self.assertRaises(_lowercase ) as cm: mock_training_loop_function() self.assertIn('''No executable batch size found, reached zero.''' , cm.exception.args[0] ) def a ( self : Union[str, Any] ): @find_executable_batch_size(starting_batch_size=1_28 ) def mock_training_loop_function(_lowercase : Optional[Any] , _lowercase : List[str] , _lowercase : str ): if batch_size != 8: raise raise_fake_out_of_memory() with self.assertRaises(_lowercase ) as cm: mock_training_loop_function(1_28 , '''hello''' , '''world''' ) self.assertIn('''Batch size was passed into `f`''' , cm.exception.args[0] ) self.assertIn('''`f(arg1=\'hello\', arg2=\'world\')''' , cm.exception.args[0] ) def a ( self : Dict ): @find_executable_batch_size(starting_batch_size=16 ) def mock_training_loop_function(_lowercase : int ): raise ValueError('''Oops, we had an error!''' ) with self.assertRaises(_lowercase ) as cm: mock_training_loop_function() self.assertIn('''Oops, we had an error!''' , cm.exception.args[0] ) @require_cuda def a ( self : str ): __UpperCAmelCase = torch.cuda.memory_allocated() __UpperCAmelCase = ModelForTest() model.cuda() self.assertGreater(torch.cuda.memory_allocated() , _lowercase ) __UpperCAmelCase = release_memory(_lowercase ) self.assertEqual(torch.cuda.memory_allocated() , _lowercase )
332
1
"""simple docstring""" from functools import reduce _lowercase : str = ( '73167176531330624919225119674426574742355349194934' '96983520312774506326239578318016984801869478851843' '85861560789112949495459501737958331952853208805511' '12540698747158523863050715693290963295227443043557' '66896648950445244523161731856403098711121722383113' '62229893423380308135336276614282806444486645238749' '30358907296290491560440772390713810515859307960866' '70172427121883998797908792274921901699720888093776' '65727333001053367881220235421809751254540594752243' '52584907711670556013604839586446706324415722155397' '53697817977846174064955149290862569321978468622482' '83972241375657056057490261407972968652414535100474' '82166370484403199890008895243450658541227588666881' '16427171479924442928230863465674813919123162824586' '17866458359124566529476545682848912883142607690042' '24219022671055626321111109370544217506941658960408' '07198403850962455444362981230987879927244284909188' '84580156166097919133875499200524063689912560717606' '05886116467109405077541002256983155200055935729725' '71636269561882670428252483600823257530420752963450' ) def lowercase__ ( snake_case_ :str = N ): return max( # mypy cannot properly interpret reduce int(reduce(lambda snake_case_ , snake_case_ : str(int(snake_case_ ) * int(snake_case_ ) ) , n[i : i + 13] ) ) for i in range(len(snake_case_ ) - 12 ) ) if __name__ == "__main__": print(f"""{solution() = }""")
332
"""simple docstring""" import argparse import copy def lowercase__ ( snake_case_ :Tuple ): __UpperCAmelCase = {} with open(snake_case_ ) as f: for line in f: if line.split()[0] not in dict_of_neighbours: __UpperCAmelCase = [] _list.append([line.split()[1], line.split()[2]] ) __UpperCAmelCase = _list else: dict_of_neighbours[line.split()[0]].append( [line.split()[1], line.split()[2]] ) if line.split()[1] not in dict_of_neighbours: __UpperCAmelCase = [] _list.append([line.split()[0], line.split()[2]] ) __UpperCAmelCase = _list else: dict_of_neighbours[line.split()[1]].append( [line.split()[0], line.split()[2]] ) return dict_of_neighbours def lowercase__ ( snake_case_ :Dict , snake_case_ :Optional[Any] ): with open(snake_case_ ) as f: __UpperCAmelCase = f.read(1 ) __UpperCAmelCase = start_node __UpperCAmelCase = [] __UpperCAmelCase = start_node __UpperCAmelCase = 0 while visiting not in first_solution: __UpperCAmelCase = 10_000 for k in dict_of_neighbours[visiting]: if int(k[1] ) < int(snake_case_ ) and k[0] not in first_solution: __UpperCAmelCase = k[1] __UpperCAmelCase = k[0] first_solution.append(snake_case_ ) __UpperCAmelCase = distance_of_first_solution + int(snake_case_ ) __UpperCAmelCase = best_node first_solution.append(snake_case_ ) __UpperCAmelCase = 0 for k in dict_of_neighbours[first_solution[-2]]: if k[0] == start_node: break position += 1 __UpperCAmelCase = ( distance_of_first_solution + int(dict_of_neighbours[first_solution[-2]][position][1] ) - 10_000 ) return first_solution, distance_of_first_solution def lowercase__ ( snake_case_ :int , snake_case_ :Tuple ): __UpperCAmelCase = [] for n in solution[1:-1]: __UpperCAmelCase = solution.index(snake_case_ ) for kn in solution[1:-1]: __UpperCAmelCase = solution.index(snake_case_ ) if n == kn: continue __UpperCAmelCase = copy.deepcopy(snake_case_ ) __UpperCAmelCase = kn __UpperCAmelCase = n __UpperCAmelCase = 0 for k in _tmp[:-1]: __UpperCAmelCase = _tmp[_tmp.index(snake_case_ ) + 1] for i in dict_of_neighbours[k]: if i[0] == next_node: __UpperCAmelCase = distance + int(i[1] ) _tmp.append(snake_case_ ) if _tmp not in neighborhood_of_solution: neighborhood_of_solution.append(_tmp ) __UpperCAmelCase = len(neighborhood_of_solution[0] ) - 1 neighborhood_of_solution.sort(key=lambda snake_case_ : x[index_of_last_item_in_the_list] ) return neighborhood_of_solution def lowercase__ ( snake_case_ :str , snake_case_ :Union[str, Any] , snake_case_ :Optional[int] , snake_case_ :Dict , snake_case_ :int ): __UpperCAmelCase = 1 __UpperCAmelCase = first_solution __UpperCAmelCase = [] __UpperCAmelCase = distance_of_first_solution __UpperCAmelCase = solution while count <= iters: __UpperCAmelCase = find_neighborhood(snake_case_ , snake_case_ ) __UpperCAmelCase = 0 __UpperCAmelCase = neighborhood[index_of_best_solution] __UpperCAmelCase = len(snake_case_ ) - 1 __UpperCAmelCase = False while not found: __UpperCAmelCase = 0 while i < len(snake_case_ ): if best_solution[i] != solution[i]: __UpperCAmelCase = best_solution[i] __UpperCAmelCase = solution[i] break __UpperCAmelCase = i + 1 if [first_exchange_node, second_exchange_node] not in tabu_list and [ second_exchange_node, first_exchange_node, ] not in tabu_list: tabu_list.append([first_exchange_node, second_exchange_node] ) __UpperCAmelCase = True __UpperCAmelCase = best_solution[:-1] __UpperCAmelCase = neighborhood[index_of_best_solution][best_cost_index] if cost < best_cost: __UpperCAmelCase = cost __UpperCAmelCase = solution else: __UpperCAmelCase = index_of_best_solution + 1 __UpperCAmelCase = neighborhood[index_of_best_solution] if len(snake_case_ ) >= size: tabu_list.pop(0 ) __UpperCAmelCase = count + 1 return best_solution_ever, best_cost def lowercase__ ( snake_case_ :str=None ): __UpperCAmelCase = generate_neighbours(args.File ) __UpperCAmelCase , __UpperCAmelCase = generate_first_solution( args.File , snake_case_ ) __UpperCAmelCase , __UpperCAmelCase = tabu_search( snake_case_ , snake_case_ , snake_case_ , args.Iterations , args.Size , ) print(F'''Best solution: {best_sol}, with total distance: {best_cost}.''' ) if __name__ == "__main__": _lowercase : List[str] = argparse.ArgumentParser(description='Tabu Search') parser.add_argument( '-f', '--File', type=str, help='Path to the file containing the data', required=True, ) parser.add_argument( '-i', '--Iterations', type=int, help='How many iterations the algorithm should perform', required=True, ) parser.add_argument( '-s', '--Size', type=int, help='Size of the tabu list', required=True ) # Pass the arguments to main method main(parser.parse_args())
332
1
"""simple docstring""" def lowercase__ ( snake_case_ :float , snake_case_ :list[float] ): if discount_rate < 0: raise ValueError('''Discount rate cannot be negative''' ) if not cash_flows: raise ValueError('''Cash flows list cannot be empty''' ) __UpperCAmelCase = sum( cash_flow / ((1 + discount_rate) ** i) for i, cash_flow in enumerate(snake_case_ ) ) return round(snake_case_ , ndigits=2 ) if __name__ == "__main__": import doctest doctest.testmod()
332
"""simple docstring""" import numpy as np from numpy import ndarray from scipy.optimize import Bounds, LinearConstraint, minimize def lowercase__ ( snake_case_ :ndarray ): return np.dot(snake_case_ , snake_case_ ) class _UpperCAmelCase : def __init__( self : Union[str, Any] , *, _lowercase : float = np.inf , _lowercase : str = "linear" , _lowercase : float = 0.0 , ): __UpperCAmelCase = regularization __UpperCAmelCase = gamma if kernel == "linear": __UpperCAmelCase = self.__linear elif kernel == "rbf": if self.gamma == 0: raise ValueError('''rbf kernel requires gamma''' ) if not isinstance(self.gamma , (float, int) ): raise ValueError('''gamma must be float or int''' ) if not self.gamma > 0: raise ValueError('''gamma must be > 0''' ) __UpperCAmelCase = self.__rbf # in the future, there could be a default value like in sklearn # sklear: def_gamma = 1/(n_features * X.var()) (wiki) # previously it was 1/(n_features) else: __UpperCAmelCase = F'''Unknown kernel: {kernel}''' raise ValueError(_lowercase ) def a ( self : Dict , _lowercase : ndarray , _lowercase : ndarray ): return np.dot(_lowercase , _lowercase ) def a ( self : Any , _lowercase : ndarray , _lowercase : ndarray ): return np.exp(-(self.gamma * norm_squared(vectora - vectora )) ) def a ( self : Union[str, Any] , _lowercase : list[ndarray] , _lowercase : ndarray ): __UpperCAmelCase = observations __UpperCAmelCase = classes # using Wolfe's Dual to calculate w. # Primal problem: minimize 1/2*norm_squared(w) # constraint: yn(w . xn + b) >= 1 # # With l a vector # Dual problem: maximize sum_n(ln) - # 1/2 * sum_n(sum_m(ln*lm*yn*ym*xn . xm)) # constraint: self.C >= ln >= 0 # and sum_n(ln*yn) = 0 # Then we get w using w = sum_n(ln*yn*xn) # At the end we can get b ~= mean(yn - w . xn) # # Since we use kernels, we only need l_star to calculate b # and to classify observations ((__UpperCAmelCase) , ) = np.shape(_lowercase ) def to_minimize(_lowercase : ndarray ) -> float: __UpperCAmelCase = 0 ((__UpperCAmelCase) , ) = np.shape(_lowercase ) for i in range(_lowercase ): for j in range(_lowercase ): s += ( candidate[i] * candidate[j] * classes[i] * classes[j] * self.kernel(observations[i] , observations[j] ) ) return 1 / 2 * s - sum(_lowercase ) __UpperCAmelCase = LinearConstraint(_lowercase , 0 , 0 ) __UpperCAmelCase = Bounds(0 , self.regularization ) __UpperCAmelCase = minimize( _lowercase , np.ones(_lowercase ) , bounds=_lowercase , constraints=[ly_contraint] ).x __UpperCAmelCase = l_star # calculating mean offset of separation plane to points __UpperCAmelCase = 0 for i in range(_lowercase ): for j in range(_lowercase ): s += classes[i] - classes[i] * self.optimum[i] * self.kernel( observations[i] , observations[j] ) __UpperCAmelCase = s / n def a ( self : List[Any] , _lowercase : ndarray ): __UpperCAmelCase = sum( self.optimum[n] * self.classes[n] * self.kernel(self.observations[n] , _lowercase ) for n in range(len(self.classes ) ) ) return 1 if s + self.offset >= 0 else -1 if __name__ == "__main__": import doctest doctest.testmod()
332
1
"""simple docstring""" from datetime import datetime import requests def lowercase__ ( snake_case_ :str ): __UpperCAmelCase = '''https://downloadgram.net/wp-json/wppress/video-downloader/video?url=''' __UpperCAmelCase = requests.get(base_url + url ).json()[0]['''urls'''][0]['''src'''] return requests.get(snake_case_ ).content if __name__ == "__main__": _lowercase : Dict = input('Enter Video/IGTV url: ').strip() _lowercase : Optional[Any] = f"""{datetime.now():%Y-%m-%d_%H:%M:%S}.mp4""" with open(file_name, 'wb') as fp: fp.write(download_video(url)) print(f"""Done. Video saved to disk as {file_name}.""")
332
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import _LazyModule _lowercase : int = {'processing_wav2vec2_with_lm': ['Wav2Vec2ProcessorWithLM']} if TYPE_CHECKING: from .processing_wavaveca_with_lm import WavaVecaProcessorWithLM else: import sys _lowercase : Union[str, Any] = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
332
1
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_torch_available, ) _lowercase : Tuple = { 'configuration_speecht5': [ 'SPEECHT5_PRETRAINED_CONFIG_ARCHIVE_MAP', 'SPEECHT5_PRETRAINED_HIFIGAN_CONFIG_ARCHIVE_MAP', 'SpeechT5Config', 'SpeechT5HifiGanConfig', ], 'feature_extraction_speecht5': ['SpeechT5FeatureExtractor'], 'processing_speecht5': ['SpeechT5Processor'], } try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : Optional[int] = ['SpeechT5Tokenizer'] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : Tuple = [ 'SPEECHT5_PRETRAINED_MODEL_ARCHIVE_LIST', 'SpeechT5ForSpeechToText', 'SpeechT5ForSpeechToSpeech', 'SpeechT5ForTextToSpeech', 'SpeechT5Model', 'SpeechT5PreTrainedModel', 'SpeechT5HifiGan', ] if TYPE_CHECKING: from .configuration_speechta import ( SPEECHT5_PRETRAINED_CONFIG_ARCHIVE_MAP, SPEECHT5_PRETRAINED_HIFIGAN_CONFIG_ARCHIVE_MAP, SpeechTaConfig, SpeechTaHifiGanConfig, ) from .feature_extraction_speechta import SpeechTaFeatureExtractor from .processing_speechta import SpeechTaProcessor try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_speechta import SpeechTaTokenizer try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_speechta import ( SPEECHT5_PRETRAINED_MODEL_ARCHIVE_LIST, SpeechTaForSpeechToSpeech, SpeechTaForSpeechToText, SpeechTaForTextToSpeech, SpeechTaHifiGan, SpeechTaModel, SpeechTaPreTrainedModel, ) else: import sys _lowercase : str = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
332
"""simple docstring""" from __future__ import annotations class _UpperCAmelCase : def __init__( self : Tuple , _lowercase : str , _lowercase : str ): __UpperCAmelCase , __UpperCAmelCase = text, pattern __UpperCAmelCase , __UpperCAmelCase = len(_lowercase ), len(_lowercase ) def a ( self : Optional[int] , _lowercase : str ): for i in range(self.patLen - 1 , -1 , -1 ): if char == self.pattern[i]: return i return -1 def a ( self : int , _lowercase : int ): for i in range(self.patLen - 1 , -1 , -1 ): if self.pattern[i] != self.text[current_pos + i]: return current_pos + i return -1 def a ( self : Optional[Any] ): # searches pattern in text and returns index positions __UpperCAmelCase = [] for i in range(self.textLen - self.patLen + 1 ): __UpperCAmelCase = self.mismatch_in_text(_lowercase ) if mismatch_index == -1: positions.append(_lowercase ) else: __UpperCAmelCase = self.match_in_pattern(self.text[mismatch_index] ) __UpperCAmelCase = ( mismatch_index - match_index ) # shifting index lgtm [py/multiple-definition] return positions _lowercase : str = 'ABAABA' _lowercase : Tuple = 'AB' _lowercase : Dict = BoyerMooreSearch(text, pattern) _lowercase : Any = bms.bad_character_heuristic() if len(positions) == 0: print('No match found') else: print('Pattern found in following positions: ') print(positions)
332
1
"""simple docstring""" from __future__ import annotations def lowercase__ ( snake_case_ :list[int] ): if not nums: return 0 __UpperCAmelCase = nums[0] __UpperCAmelCase = 0 for num in nums[1:]: __UpperCAmelCase , __UpperCAmelCase = ( max_excluding + num, max(snake_case_ , snake_case_ ), ) return max(snake_case_ , snake_case_ ) if __name__ == "__main__": import doctest doctest.testmod()
332
"""simple docstring""" from __future__ import annotations from collections import deque from collections.abc import Sequence from dataclasses import dataclass from typing import Any @dataclass class _UpperCAmelCase : a__ : int a__ : Node | None = None a__ : Node | None = None def lowercase__ ( ): __UpperCAmelCase = Node(1 ) __UpperCAmelCase = Node(2 ) __UpperCAmelCase = Node(3 ) __UpperCAmelCase = Node(4 ) __UpperCAmelCase = Node(5 ) return tree def lowercase__ ( snake_case_ :Node | None ): return [root.data, *preorder(root.left ), *preorder(root.right )] if root else [] def lowercase__ ( snake_case_ :Node | None ): return postorder(root.left ) + postorder(root.right ) + [root.data] if root else [] def lowercase__ ( snake_case_ :Node | None ): return [*inorder(root.left ), root.data, *inorder(root.right )] if root else [] def lowercase__ ( snake_case_ :Node | None ): return (max(height(root.left ) , height(root.right ) ) + 1) if root else 0 def lowercase__ ( snake_case_ :Node | None ): __UpperCAmelCase = [] if root is None: return output __UpperCAmelCase = deque([root] ) while process_queue: __UpperCAmelCase = process_queue.popleft() output.append(node.data ) if node.left: process_queue.append(node.left ) if node.right: process_queue.append(node.right ) return output def lowercase__ ( snake_case_ :Node | None , snake_case_ :int ): __UpperCAmelCase = [] def populate_output(snake_case_ :Node | None , snake_case_ :int ) -> None: if not root: return if level == 1: output.append(root.data ) elif level > 1: populate_output(root.left , level - 1 ) populate_output(root.right , level - 1 ) populate_output(snake_case_ , snake_case_ ) return output def lowercase__ ( snake_case_ :Node | None , snake_case_ :int ): __UpperCAmelCase = [] def populate_output(snake_case_ :Node | None , snake_case_ :int ) -> None: if root is None: return if level == 1: output.append(root.data ) elif level > 1: populate_output(root.right , level - 1 ) populate_output(root.left , level - 1 ) populate_output(snake_case_ , snake_case_ ) return output def lowercase__ ( snake_case_ :Node | None ): if root is None: return [] __UpperCAmelCase = [] __UpperCAmelCase = 0 __UpperCAmelCase = height(snake_case_ ) for h in range(1 , height_tree + 1 ): if not flag: output.append(get_nodes_from_left_to_right(snake_case_ , snake_case_ ) ) __UpperCAmelCase = 1 else: output.append(get_nodes_from_right_to_left(snake_case_ , snake_case_ ) ) __UpperCAmelCase = 0 return output def lowercase__ ( ): # Main function for testing. __UpperCAmelCase = make_tree() print(F'''In-order Traversal: {inorder(snake_case_ )}''' ) print(F'''Pre-order Traversal: {preorder(snake_case_ )}''' ) print(F'''Post-order Traversal: {postorder(snake_case_ )}''' , '''\n''' ) print(F'''Height of Tree: {height(snake_case_ )}''' , '''\n''' ) print('''Complete Level Order Traversal: ''' ) print(level_order(snake_case_ ) , '''\n''' ) print('''Level-wise order Traversal: ''' ) for level in range(1 , height(snake_case_ ) + 1 ): print(F'''Level {level}:''' , get_nodes_from_left_to_right(snake_case_ , level=snake_case_ ) ) print('''\nZigZag order Traversal: ''' ) print(zigzag(snake_case_ ) ) if __name__ == "__main__": import doctest doctest.testmod() main()
332
1
"""simple docstring""" import argparse import json import subprocess def lowercase__ ( snake_case_ :List[Any] , snake_case_ :List[str] ): __UpperCAmelCase = [] __UpperCAmelCase = ( F'''curl -H "Accept: application/vnd.github+json" -H "Authorization: Bearer {token}"''' ''' https://api.github.com/repos/huggingface/transformers/actions/runners''' ) __UpperCAmelCase = subprocess.run(snake_case_ , shell=snake_case_ , stdout=subprocess.PIPE ) __UpperCAmelCase = output.stdout.decode('''utf-8''' ) __UpperCAmelCase = json.loads(snake_case_ ) __UpperCAmelCase = status['''runners'''] for runner in runners: if runner["name"] in target_runners: if runner["status"] == "offline": offline_runners.append(snake_case_ ) # save the result so we can report them on Slack with open('''offline_runners.txt''' , '''w''' ) as fp: fp.write(json.dumps(snake_case_ ) ) if len(snake_case_ ) > 0: __UpperCAmelCase = '''\n'''.join([x['''name'''] for x in offline_runners] ) raise ValueError(F'''The following runners are offline:\n{failed}''' ) if __name__ == "__main__": def lowercase__ ( snake_case_ :int ): return values.split(''',''' ) _lowercase : Any = argparse.ArgumentParser() # Required parameters parser.add_argument( '--target_runners', default=None, type=list_str, required=True, help='Comma-separated list of runners to check status.', ) parser.add_argument( '--token', default=None, type=str, required=True, help='A token that has actions:read permission.' ) _lowercase : Dict = parser.parse_args() get_runner_status(args.target_runners, args.token)
332
"""simple docstring""" import unittest from transformers import is_torch_available from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow if is_torch_available(): import torch from transformers import XLMRobertaModel @require_sentencepiece @require_tokenizers @require_torch class _UpperCAmelCase ( unittest.TestCase ): @slow def a ( self : str ): __UpperCAmelCase = XLMRobertaModel.from_pretrained('''xlm-roberta-base''' ) __UpperCAmelCase = torch.tensor([[0, 5_81, 1_02_69, 83, 9_99_42, 1_36, 6_07_42, 23, 70, 8_05_83, 1_82_76, 2]] ) # The dog is cute and lives in the garden house __UpperCAmelCase = torch.Size((1, 12, 7_68) ) # batch_size, sequence_length, embedding_vector_dim __UpperCAmelCase = torch.tensor( [[-0.0_101, 0.1_218, -0.0_803, 0.0_801, 0.1_327, 0.0_776, -0.1_215, 0.2_383, 0.3_338, 0.3_106, 0.0_300, 0.0_252]] ) # xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.base') # xlmr.eval() # expected_output_values_last_dim = xlmr.extract_features(input_ids[0])[:, :, -1] with torch.no_grad(): __UpperCAmelCase = model(_lowercase )['''last_hidden_state'''].detach() self.assertEqual(output.shape , _lowercase ) # compare the actual values for a slice of last dim self.assertTrue(torch.allclose(output[:, :, -1] , _lowercase , atol=1E-3 ) ) @slow def a ( self : str ): __UpperCAmelCase = XLMRobertaModel.from_pretrained('''xlm-roberta-large''' ) __UpperCAmelCase = torch.tensor([[0, 5_81, 1_02_69, 83, 9_99_42, 1_36, 6_07_42, 23, 70, 8_05_83, 1_82_76, 2]] ) # The dog is cute and lives in the garden house __UpperCAmelCase = torch.Size((1, 12, 10_24) ) # batch_size, sequence_length, embedding_vector_dim __UpperCAmelCase = torch.tensor( [[-0.0_699, -0.0_318, 0.0_705, -0.1_241, 0.0_999, -0.0_520, 0.1_004, -0.1_838, -0.4_704, 0.1_437, 0.0_821, 0.0_126]] ) # xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.large') # xlmr.eval() # expected_output_values_last_dim = xlmr.extract_features(input_ids[0])[:, :, -1] with torch.no_grad(): __UpperCAmelCase = model(_lowercase )['''last_hidden_state'''].detach() self.assertEqual(output.shape , _lowercase ) # compare the actual values for a slice of last dim self.assertTrue(torch.allclose(output[:, :, -1] , _lowercase , atol=1E-3 ) )
332
1
"""simple docstring""" import unittest import numpy as np from transformers import AlbertConfig, 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.albert.modeling_flax_albert import ( FlaxAlbertForMaskedLM, FlaxAlbertForMultipleChoice, FlaxAlbertForPreTraining, FlaxAlbertForQuestionAnswering, FlaxAlbertForSequenceClassification, FlaxAlbertForTokenClassification, FlaxAlbertModel, ) class _UpperCAmelCase ( unittest.TestCase ): def __init__( self : Any , _lowercase : Optional[Any] , _lowercase : List[Any]=13 , _lowercase : Dict=7 , _lowercase : int=True , _lowercase : int=True , _lowercase : int=True , _lowercase : Optional[Any]=True , _lowercase : List[Any]=99 , _lowercase : str=32 , _lowercase : Any=5 , _lowercase : Optional[int]=4 , _lowercase : Optional[Any]=37 , _lowercase : str="gelu" , _lowercase : Any=0.1 , _lowercase : Tuple=0.1 , _lowercase : Union[str, Any]=5_12 , _lowercase : Any=16 , _lowercase : Union[str, Any]=2 , _lowercase : Dict=0.02 , _lowercase : int=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 a ( self : Union[str, 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 = None if self.use_token_type_ids: __UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) __UpperCAmelCase = AlbertConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , is_decoder=_lowercase , initializer_range=self.initializer_range , ) return config, input_ids, token_type_ids, attention_mask def a ( self : str ): __UpperCAmelCase = self.prepare_config_and_inputs() __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase = config_and_inputs __UpperCAmelCase = {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': attention_mask} return config, inputs_dict @require_flax class _UpperCAmelCase ( _lowerCAmelCase , unittest.TestCase ): a__ : Union[str, Any] = ( ( FlaxAlbertModel, FlaxAlbertForPreTraining, FlaxAlbertForMaskedLM, FlaxAlbertForMultipleChoice, FlaxAlbertForQuestionAnswering, FlaxAlbertForSequenceClassification, FlaxAlbertForTokenClassification, FlaxAlbertForQuestionAnswering, ) if is_flax_available() else () ) def a ( self : Union[str, Any] ): __UpperCAmelCase = FlaxAlbertModelTester(self ) @slow def a ( self : Tuple ): for model_class_name in self.all_model_classes: __UpperCAmelCase = model_class_name.from_pretrained('''albert-base-v2''' ) __UpperCAmelCase = model(np.ones((1, 1) ) ) self.assertIsNotNone(_lowercase ) @require_flax class _UpperCAmelCase ( unittest.TestCase ): @slow def a ( self : Any ): __UpperCAmelCase = FlaxAlbertModel.from_pretrained('''albert-base-v2''' ) __UpperCAmelCase = np.array([[0, 3_45, 2_32, 3_28, 7_40, 1_40, 16_95, 69, 60_78, 15_88, 2]] ) __UpperCAmelCase = np.array([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] ) __UpperCAmelCase = model(_lowercase , attention_mask=_lowercase )[0] __UpperCAmelCase = (1, 11, 7_68) self.assertEqual(output.shape , _lowercase ) __UpperCAmelCase = np.array( [[[-0.6_513, 1.5_035, -0.2_766], [-0.6_515, 1.5_046, -0.2_780], [-0.6_512, 1.5_049, -0.2_784]]] ) self.assertTrue(jnp.allclose(output[:, 1:4, 1:4] , _lowercase , atol=1E-4 ) )
332
"""simple docstring""" def lowercase__ ( snake_case_ :Union[str, Any] ): # if the collection is empty, returns empty if collection == []: return [] # get some information about the collection __UpperCAmelCase = len(snake_case_ ) __UpperCAmelCase = max(snake_case_ ) __UpperCAmelCase = min(snake_case_ ) # create the counting array __UpperCAmelCase = coll_max + 1 - coll_min __UpperCAmelCase = [0] * counting_arr_length # count how much a number appears in the collection for number in collection: counting_arr[number - coll_min] += 1 # sum each position with it's predecessors. now, counting_arr[i] tells # us how many elements <= i has in the collection for i in range(1 , snake_case_ ): __UpperCAmelCase = counting_arr[i] + counting_arr[i - 1] # create the output collection __UpperCAmelCase = [0] * coll_len # place the elements in the output, respecting the original order (stable # sort) from end to begin, updating counting_arr for i in reversed(range(0 , snake_case_ ) ): __UpperCAmelCase = collection[i] counting_arr[collection[i] - coll_min] -= 1 return ordered def lowercase__ ( snake_case_ :str ): return "".join([chr(snake_case_ ) for i in counting_sort([ord(snake_case_ ) for c in string] )] ) if __name__ == "__main__": # Test string sort assert counting_sort_string('thisisthestring') == "eghhiiinrsssttt" _lowercase : int = input('Enter numbers separated by a comma:\n').strip() _lowercase : int = [int(item) for item in user_input.split(',')] print(counting_sort(unsorted))
332
1
"""simple docstring""" import heapq as hq import math from collections.abc import Iterator class _UpperCAmelCase : def __init__( self : Union[str, Any] , _lowercase : Optional[Any] ): __UpperCAmelCase = str(id_ ) __UpperCAmelCase = None __UpperCAmelCase = None __UpperCAmelCase = [] __UpperCAmelCase = {} # {vertex:distance} def __lt__( self : str , _lowercase : List[Any] ): return self.key < other.key def __repr__( self : int ): return self.id def a ( self : Union[str, Any] , _lowercase : int ): self.neighbors.append(_lowercase ) def a ( self : List[Any] , _lowercase : Optional[Any] , _lowercase : int ): __UpperCAmelCase = weight def lowercase__ ( snake_case_ :int , snake_case_ :Any , snake_case_ :Union[str, Any] , snake_case_ :List[str] ): # add the neighbors: graph[a - 1].add_neighbor(graph[b - 1] ) graph[b - 1].add_neighbor(graph[a - 1] ) # add the edges: graph[a - 1].add_edge(graph[b - 1] , snake_case_ ) graph[b - 1].add_edge(graph[a - 1] , snake_case_ ) def lowercase__ ( snake_case_ :list , snake_case_ :Vertex ): __UpperCAmelCase = [] for u in graph: __UpperCAmelCase = math.inf __UpperCAmelCase = None __UpperCAmelCase = 0 __UpperCAmelCase = graph[:] while q: __UpperCAmelCase = min(snake_case_ ) q.remove(snake_case_ ) for v in u.neighbors: if (v in q) and (u.edges[v.id] < v.key): __UpperCAmelCase = u __UpperCAmelCase = u.edges[v.id] for i in range(1 , len(snake_case_ ) ): a.append((int(graph[i].id ) + 1, int(graph[i].pi.id ) + 1) ) return a def lowercase__ ( snake_case_ :list , snake_case_ :Vertex ): for u in graph: __UpperCAmelCase = math.inf __UpperCAmelCase = None __UpperCAmelCase = 0 __UpperCAmelCase = list(snake_case_ ) hq.heapify(snake_case_ ) while h: __UpperCAmelCase = hq.heappop(snake_case_ ) for v in u.neighbors: if (v in h) and (u.edges[v.id] < v.key): __UpperCAmelCase = u __UpperCAmelCase = u.edges[v.id] hq.heapify(snake_case_ ) for i in range(1 , len(snake_case_ ) ): yield (int(graph[i].id ) + 1, int(graph[i].pi.id ) + 1) def lowercase__ ( ): pass if __name__ == "__main__": import doctest doctest.testmod()
332
"""simple docstring""" from collections import defaultdict def lowercase__ ( snake_case_ :str , snake_case_ :str ): __UpperCAmelCase = first_str.lower().strip() __UpperCAmelCase = second_str.lower().strip() # Remove whitespace __UpperCAmelCase = first_str.replace(''' ''' , '''''' ) __UpperCAmelCase = second_str.replace(''' ''' , '''''' ) # Strings of different lengths are not anagrams if len(snake_case_ ) != len(snake_case_ ): return False # Default values for count should be 0 __UpperCAmelCase = defaultdict(snake_case_ ) # For each character in input strings, # increment count in the corresponding for i in range(len(snake_case_ ) ): 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() _lowercase : List[Any] = input('Enter the first string ').strip() _lowercase : Tuple = input('Enter the second string ').strip() _lowercase : str = check_anagrams(input_a, input_b) print(f"""{input_a} and {input_b} are {"" if status else "not "}anagrams.""")
332
1
"""simple docstring""" from collections import UserDict from typing import List, Union from ..utils import ( add_end_docstrings, is_tf_available, is_torch_available, is_vision_available, logging, requires_backends, ) from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING if is_tf_available(): from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING from ..tf_utils import stable_softmax _lowercase : List[Any] = logging.get_logger(__name__) @add_end_docstrings(_lowerCAmelCase ) class _UpperCAmelCase ( _lowerCAmelCase ): def __init__( self : Union[str, Any] , **_lowercase : Optional[Any] ): super().__init__(**_lowercase ) requires_backends(self , '''vision''' ) self.check_model_type( TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING if self.framework == '''tf''' else MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING ) def __call__( self : Union[str, Any] , _lowercase : Union[str, List[str], "Image", List["Image"]] , **_lowercase : Tuple ): return super().__call__(_lowercase , **_lowercase ) def a ( self : str , **_lowercase : Any ): __UpperCAmelCase = {} if "candidate_labels" in kwargs: __UpperCAmelCase = kwargs['''candidate_labels'''] if "hypothesis_template" in kwargs: __UpperCAmelCase = kwargs['''hypothesis_template'''] return preprocess_params, {}, {} def a ( self : str , _lowercase : str , _lowercase : Union[str, Any]=None , _lowercase : List[str]="This is a photo of {}." ): __UpperCAmelCase = load_image(_lowercase ) __UpperCAmelCase = self.image_processor(images=[image] , return_tensors=self.framework ) __UpperCAmelCase = candidate_labels __UpperCAmelCase = [hypothesis_template.format(_lowercase ) for x in candidate_labels] __UpperCAmelCase = self.tokenizer(_lowercase , return_tensors=self.framework , padding=_lowercase ) __UpperCAmelCase = [text_inputs] return inputs def a ( self : Dict , _lowercase : Any ): __UpperCAmelCase = model_inputs.pop('''candidate_labels''' ) __UpperCAmelCase = model_inputs.pop('''text_inputs''' ) if isinstance(text_inputs[0] , _lowercase ): __UpperCAmelCase = text_inputs[0] else: # Batching case. __UpperCAmelCase = text_inputs[0][0] __UpperCAmelCase = self.model(**_lowercase , **_lowercase ) __UpperCAmelCase = { '''candidate_labels''': candidate_labels, '''logits''': outputs.logits_per_image, } return model_outputs def a ( self : Optional[Any] , _lowercase : Optional[Any] ): __UpperCAmelCase = model_outputs.pop('''candidate_labels''' ) __UpperCAmelCase = model_outputs['''logits'''][0] if self.framework == "pt": __UpperCAmelCase = logits.softmax(dim=-1 ).squeeze(-1 ) __UpperCAmelCase = probs.tolist() if not isinstance(_lowercase , _lowercase ): __UpperCAmelCase = [scores] elif self.framework == "tf": __UpperCAmelCase = stable_softmax(_lowercase , axis=-1 ) __UpperCAmelCase = probs.numpy().tolist() else: raise ValueError(F'''Unsupported framework: {self.framework}''' ) __UpperCAmelCase = [ {'''score''': score, '''label''': candidate_label} for score, candidate_label in sorted(zip(_lowercase , _lowercase ) , key=lambda _lowercase : -x[0] ) ] return result
332
"""simple docstring""" import os import tempfile import unittest from pathlib import Path from transformers import AutoConfig, is_torch_available from transformers.testing_utils import require_torch, torch_device if is_torch_available(): from transformers import PyTorchBenchmark, PyTorchBenchmarkArguments @require_torch class _UpperCAmelCase ( unittest.TestCase ): def a ( self : Dict , _lowercase : Union[str, Any] ): for model_result in results.values(): for batch_size, sequence_length in zip(model_result['''bs'''] , model_result['''ss'''] ): __UpperCAmelCase = model_result['''result'''][batch_size][sequence_length] self.assertIsNotNone(_lowercase ) def a ( self : str ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : List[str] ): __UpperCAmelCase = '''sgugger/tiny-distilbert-classification''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , only_pretrain_model=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : str ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , torchscript=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) @unittest.skipIf(torch_device == '''cpu''' , '''Cant do half precision''' ) def a ( self : Optional[Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , fpaa=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : int ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) # set architectures equal to `None` __UpperCAmelCase = None __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : Tuple ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) @unittest.skipIf(torch_device == '''cpu''' , '''Can\'t do half precision''' ) def a ( self : Optional[Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , fpaa=_lowercase , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) def a ( self : Any ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : str ): __UpperCAmelCase = '''sshleifer/tinier_bart''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : Union[str, Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) def a ( self : int ): __UpperCAmelCase = '''sshleifer/tinier_bart''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) def a ( self : Optional[Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' with tempfile.TemporaryDirectory() as tmp_dir: __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , save_to_csv=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , inference_time_csv_file=os.path.join(_lowercase , '''inf_time.csv''' ) , train_memory_csv_file=os.path.join(_lowercase , '''train_mem.csv''' ) , inference_memory_csv_file=os.path.join(_lowercase , '''inf_mem.csv''' ) , train_time_csv_file=os.path.join(_lowercase , '''train_time.csv''' ) , env_info_csv_file=os.path.join(_lowercase , '''env.csv''' ) , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) benchmark.run() self.assertTrue(Path(os.path.join(_lowercase , '''inf_time.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(_lowercase , '''train_time.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(_lowercase , '''inf_mem.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(_lowercase , '''train_mem.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(_lowercase , '''env.csv''' ) ).exists() ) def a ( self : List[Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' def _check_summary_is_not_empty(_lowercase : str ): self.assertTrue(hasattr(_lowercase , '''sequential''' ) ) self.assertTrue(hasattr(_lowercase , '''cumulative''' ) ) self.assertTrue(hasattr(_lowercase , '''current''' ) ) self.assertTrue(hasattr(_lowercase , '''total''' ) ) with tempfile.TemporaryDirectory() as tmp_dir: __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , log_filename=os.path.join(_lowercase , '''log.txt''' ) , log_print=_lowercase , trace_memory_line_by_line=_lowercase , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() _check_summary_is_not_empty(result.inference_summary ) _check_summary_is_not_empty(result.train_summary ) self.assertTrue(Path(os.path.join(_lowercase , '''log.txt''' ) ).exists() )
332
1
"""simple docstring""" import warnings from ...utils import logging from .image_processing_videomae import VideoMAEImageProcessor _lowercase : int = logging.get_logger(__name__) class _UpperCAmelCase ( _lowerCAmelCase ): def __init__( self : Union[str, Any] , *_lowercase : Any , **_lowercase : List[Any] ): warnings.warn( '''The class VideoMAEFeatureExtractor is deprecated and will be removed in version 5 of Transformers.''' ''' Please use VideoMAEImageProcessor instead.''' , _lowercase , ) super().__init__(*_lowercase , **_lowercase )
332
"""simple docstring""" from typing import Dict from .base import GenericTensor, Pipeline class _UpperCAmelCase ( _lowerCAmelCase ): def a ( self : Tuple , _lowercase : Dict=None , _lowercase : str=None , _lowercase : Union[str, Any]=None , **_lowercase : Tuple ): if tokenize_kwargs is None: __UpperCAmelCase = {} if truncation is not None: if "truncation" in tokenize_kwargs: raise ValueError( '''truncation parameter defined twice (given as keyword argument as well as in tokenize_kwargs)''' ) __UpperCAmelCase = truncation __UpperCAmelCase = tokenize_kwargs __UpperCAmelCase = {} if return_tensors is not None: __UpperCAmelCase = return_tensors return preprocess_params, {}, postprocess_params def a ( self : int , _lowercase : Optional[Any] , **_lowercase : Union[str, Any] ): __UpperCAmelCase = self.framework __UpperCAmelCase = self.tokenizer(_lowercase , return_tensors=_lowercase , **_lowercase ) return model_inputs def a ( self : List[str] , _lowercase : Tuple ): __UpperCAmelCase = self.model(**_lowercase ) return model_outputs def a ( self : int , _lowercase : Tuple , _lowercase : str=False ): # [0] is the first available tensor, logits or last_hidden_state. if return_tensors: return model_outputs[0] if self.framework == "pt": return model_outputs[0].tolist() elif self.framework == "tf": return model_outputs[0].numpy().tolist() def __call__( self : List[Any] , *_lowercase : Optional[Any] , **_lowercase : Union[str, Any] ): return super().__call__(*_lowercase , **_lowercase )
332
1
"""simple docstring""" from typing import List, Optional, Union import numpy as np import torch import torchaudio.compliance.kaldi as ta_kaldi from ...feature_extraction_sequence_utils import SequenceFeatureExtractor from ...feature_extraction_utils import BatchFeature from ...utils import PaddingStrategy, TensorType, logging _lowercase : Optional[Any] = logging.get_logger(__name__) class _UpperCAmelCase ( _lowerCAmelCase ): a__ : Any = ["input_features", "attention_mask"] def __init__( self : int , _lowercase : Tuple=80 , _lowercase : Any=1_60_00 , _lowercase : Union[str, Any]=80 , _lowercase : Any=0.0 , _lowercase : Optional[int]=True , _lowercase : Optional[Any]=True , _lowercase : List[str]=True , **_lowercase : Dict , ): super().__init__(feature_size=_lowercase , sampling_rate=_lowercase , padding_value=_lowercase , **_lowercase ) __UpperCAmelCase = num_mel_bins __UpperCAmelCase = do_ceptral_normalize __UpperCAmelCase = normalize_means __UpperCAmelCase = normalize_vars __UpperCAmelCase = True def a ( self : Dict , _lowercase : np.ndarray , ): __UpperCAmelCase = waveform * (2**15) # Kaldi compliance: 16-bit signed integers __UpperCAmelCase = torch.from_numpy(_lowercase ).unsqueeze(0 ) __UpperCAmelCase = ta_kaldi.fbank(_lowercase , num_mel_bins=self.num_mel_bins , sample_frequency=self.sampling_rate ) return features.numpy() @staticmethod def a ( _lowercase : np.ndarray , _lowercase : int , _lowercase : Optional[bool] = True , _lowercase : Optional[bool] = True , _lowercase : float = 0.0 , ): # make sure we normalize float32 arrays if normalize_means: __UpperCAmelCase = x[:input_length].mean(axis=0 ) __UpperCAmelCase = np.subtract(_lowercase , _lowercase ) if normalize_vars: __UpperCAmelCase = x[:input_length].std(axis=0 ) __UpperCAmelCase = np.divide(_lowercase , _lowercase ) if input_length < x.shape[0]: __UpperCAmelCase = padding_value # make sure array is in float32 __UpperCAmelCase = x.astype(np.floataa ) return x def a ( self : List[str] , _lowercase : List[np.ndarray] , _lowercase : Optional[np.ndarray] = None ): __UpperCAmelCase = attention_mask.sum(-1 ) if attention_mask is not None else [x.shape[0] for x in input_features] return [ self.utterance_cmvn(_lowercase , _lowercase , self.normalize_means , self.normalize_vars , self.padding_value ) for x, n in zip(_lowercase , _lowercase ) ] def __call__( self : Union[str, Any] , _lowercase : Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]] , _lowercase : Union[bool, str, PaddingStrategy] = False , _lowercase : Optional[int] = None , _lowercase : bool = False , _lowercase : Optional[int] = None , _lowercase : Optional[Union[str, TensorType]] = None , _lowercase : Optional[int] = None , _lowercase : Optional[bool] = None , **_lowercase : Tuple , ): if sampling_rate is not None: if sampling_rate != self.sampling_rate: raise ValueError( F'''The model corresponding to this feature extractor: {self} was trained using a sampling rate of''' F''' {self.sampling_rate}. Please make sure that the provided `raw_speech` input was sampled with''' F''' {self.sampling_rate} and not {sampling_rate}.''' ) else: logger.warning( '''It is strongly recommended to pass the `sampling_rate` argument to this function. ''' '''Failing to do so can result in silent errors that might be hard to debug.''' ) __UpperCAmelCase = isinstance(_lowercase , np.ndarray ) and len(raw_speech.shape ) > 1 if is_batched_numpy and len(raw_speech.shape ) > 2: raise ValueError(F'''Only mono-channel audio is supported for input to {self}''' ) __UpperCAmelCase = is_batched_numpy or ( isinstance(_lowercase , (list, tuple) ) and (isinstance(raw_speech[0] , (np.ndarray, tuple, list) )) ) if is_batched: __UpperCAmelCase = [np.asarray(_lowercase , dtype=np.floataa ) for speech in raw_speech] elif not is_batched and not isinstance(_lowercase , np.ndarray ): __UpperCAmelCase = np.asarray(_lowercase , dtype=np.floataa ) elif isinstance(_lowercase , np.ndarray ) and raw_speech.dtype is np.dtype(np.floataa ): __UpperCAmelCase = raw_speech.astype(np.floataa ) # always return batch if not is_batched: __UpperCAmelCase = [raw_speech] # extract fbank features __UpperCAmelCase = [self._extract_fbank_features(_lowercase ) for waveform in raw_speech] # convert into correct format for padding __UpperCAmelCase = BatchFeature({'''input_features''': features} ) __UpperCAmelCase = self.pad( _lowercase , padding=_lowercase , max_length=_lowercase , truncation=_lowercase , pad_to_multiple_of=_lowercase , return_attention_mask=_lowercase , **_lowercase , ) # make sure list is in array format __UpperCAmelCase = padded_inputs.get('''input_features''' ) if isinstance(input_features[0] , _lowercase ): __UpperCAmelCase = [np.asarray(_lowercase , dtype=np.floataa ) for feature in input_features] __UpperCAmelCase = padded_inputs.get('''attention_mask''' ) if attention_mask is not None: __UpperCAmelCase = [np.asarray(_lowercase , dtype=np.intaa ) for array in attention_mask] # Utterance-level cepstral mean and variance normalization if self.do_ceptral_normalize: __UpperCAmelCase = ( np.array(_lowercase , dtype=np.intaa ) if self._get_padding_strategies(_lowercase , max_length=_lowercase ) is not PaddingStrategy.DO_NOT_PAD else None ) __UpperCAmelCase = self.normalize( padded_inputs['''input_features'''] , attention_mask=_lowercase ) if return_tensors is not None: __UpperCAmelCase = padded_inputs.convert_to_tensors(_lowercase ) return padded_inputs
332
"""simple docstring""" from typing import List, Optional, Tuple, Union import PIL import torch from torchvision import transforms from diffusers.pipeline_utils import DiffusionPipeline, ImagePipelineOutput from diffusers.schedulers import DDIMScheduler from diffusers.utils import randn_tensor _lowercase : Union[str, Any] = transforms.Compose( [ transforms.Resize((2_56, 2_56)), transforms.ToTensor(), transforms.Normalize([0.5], [0.5]), ] ) def lowercase__ ( snake_case_ :List[Any] ): if isinstance(snake_case_ , torch.Tensor ): return image elif isinstance(snake_case_ , PIL.Image.Image ): __UpperCAmelCase = [image] __UpperCAmelCase = [trans(img.convert('''RGB''' ) ) for img in image] __UpperCAmelCase = torch.stack(snake_case_ ) return image class _UpperCAmelCase ( _lowerCAmelCase ): def __init__( self : Any , _lowercase : str , _lowercase : str ): super().__init__() # make sure scheduler can always be converted to DDIM __UpperCAmelCase = DDIMScheduler.from_config(scheduler.config ) self.register_modules(unet=_lowercase , scheduler=_lowercase ) def a ( self : int , _lowercase : List[str] ): if strength < 0 or strength > 1: raise ValueError(F'''The value of strength should in [0.0, 1.0] but is {strength}''' ) def a ( self : List[Any] , _lowercase : List[Any] , _lowercase : Optional[Any] , _lowercase : int ): # get the original timestep using init_timestep __UpperCAmelCase = min(int(num_inference_steps * strength ) , _lowercase ) __UpperCAmelCase = max(num_inference_steps - init_timestep , 0 ) __UpperCAmelCase = self.scheduler.timesteps[t_start:] return timesteps, num_inference_steps - t_start def a ( self : Optional[Any] , _lowercase : Union[str, Any] , _lowercase : Union[str, Any] , _lowercase : Optional[Any] , _lowercase : List[str] , _lowercase : Tuple , _lowercase : Optional[int]=None ): if not isinstance(_lowercase , (torch.Tensor, PIL.Image.Image, list) ): raise ValueError( F'''`image` has to be of type `torch.Tensor`, `PIL.Image.Image` or list but is {type(_lowercase )}''' ) __UpperCAmelCase = image.to(device=_lowercase , dtype=_lowercase ) 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.''' ) __UpperCAmelCase = init_latents.shape __UpperCAmelCase = randn_tensor(_lowercase , generator=_lowercase , device=_lowercase , dtype=_lowercase ) # get latents print('''add noise to latents at timestep''' , _lowercase ) __UpperCAmelCase = self.scheduler.add_noise(_lowercase , _lowercase , _lowercase ) __UpperCAmelCase = init_latents return latents @torch.no_grad() def __call__( self : Any , _lowercase : Union[torch.FloatTensor, PIL.Image.Image] = None , _lowercase : float = 0.8 , _lowercase : int = 1 , _lowercase : Optional[Union[torch.Generator, List[torch.Generator]]] = None , _lowercase : float = 0.0 , _lowercase : int = 50 , _lowercase : Optional[bool] = None , _lowercase : Optional[str] = "pil" , _lowercase : bool = True , ): self.check_inputs(_lowercase ) # 2. Preprocess image __UpperCAmelCase = preprocess(_lowercase ) # 3. set timesteps self.scheduler.set_timesteps(_lowercase , device=self.device ) __UpperCAmelCase , __UpperCAmelCase = self.get_timesteps(_lowercase , _lowercase , self.device ) __UpperCAmelCase = timesteps[:1].repeat(_lowercase ) # 4. Prepare latent variables __UpperCAmelCase = self.prepare_latents(_lowercase , _lowercase , _lowercase , self.unet.dtype , self.device , _lowercase ) __UpperCAmelCase = latents # 5. Denoising loop for t in self.progress_bar(_lowercase ): # 1. predict noise model_output __UpperCAmelCase = 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 __UpperCAmelCase = self.scheduler.step( _lowercase , _lowercase , _lowercase , eta=_lowercase , use_clipped_model_output=_lowercase , generator=_lowercase , ).prev_sample __UpperCAmelCase = (image / 2 + 0.5).clamp(0 , 1 ) __UpperCAmelCase = image.cpu().permute(0 , 2 , 3 , 1 ).numpy() if output_type == "pil": __UpperCAmelCase = self.numpy_to_pil(_lowercase ) if not return_dict: return (image, latent_timestep.item()) return ImagePipelineOutput(images=_lowercase )
332
1
"""simple docstring""" import shutil import tempfile import unittest import numpy as np import pytest from transformers.testing_utils import require_vision from transformers.utils import is_vision_available if is_vision_available(): from PIL import Image from transformers import ( AutoProcessor, BertTokenizerFast, BlipImageProcessor, GPTaTokenizer, InstructBlipProcessor, PreTrainedTokenizerFast, ) @require_vision class _UpperCAmelCase ( unittest.TestCase ): def a ( self : Union[str, Any] ): __UpperCAmelCase = tempfile.mkdtemp() __UpperCAmelCase = BlipImageProcessor() __UpperCAmelCase = GPTaTokenizer.from_pretrained('''hf-internal-testing/tiny-random-GPT2Model''' ) __UpperCAmelCase = BertTokenizerFast.from_pretrained('''hf-internal-testing/tiny-random-bert''' ) __UpperCAmelCase = InstructBlipProcessor(_lowercase , _lowercase , _lowercase ) processor.save_pretrained(self.tmpdirname ) def a ( self : Optional[int] , **_lowercase : Tuple ): return AutoProcessor.from_pretrained(self.tmpdirname , **_lowercase ).tokenizer def a ( self : List[Any] , **_lowercase : Any ): return AutoProcessor.from_pretrained(self.tmpdirname , **_lowercase ).image_processor def a ( self : Optional[Any] , **_lowercase : int ): return AutoProcessor.from_pretrained(self.tmpdirname , **_lowercase ).qformer_tokenizer def a ( self : Any ): shutil.rmtree(self.tmpdirname ) def a ( self : List[str] ): __UpperCAmelCase = [np.random.randint(2_55 , size=(3, 30, 4_00) , dtype=np.uinta )] __UpperCAmelCase = [Image.fromarray(np.moveaxis(_lowercase , 0 , -1 ) ) for x in image_inputs] return image_inputs def a ( self : Union[str, Any] ): __UpperCAmelCase = InstructBlipProcessor( tokenizer=self.get_tokenizer() , image_processor=self.get_image_processor() , qformer_tokenizer=self.get_qformer_tokenizer() , ) processor.save_pretrained(self.tmpdirname ) __UpperCAmelCase = self.get_tokenizer(bos_token='''(BOS)''' , eos_token='''(EOS)''' ) __UpperCAmelCase = self.get_image_processor(do_normalize=_lowercase , padding_value=1.0 ) __UpperCAmelCase = InstructBlipProcessor.from_pretrained( self.tmpdirname , bos_token='''(BOS)''' , eos_token='''(EOS)''' , do_normalize=_lowercase , padding_value=1.0 ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.tokenizer , _lowercase ) self.assertEqual(processor.image_processor.to_json_string() , image_processor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.image_processor , _lowercase ) self.assertIsInstance(processor.qformer_tokenizer , _lowercase ) def a ( self : Any ): __UpperCAmelCase = self.get_image_processor() __UpperCAmelCase = self.get_tokenizer() __UpperCAmelCase = self.get_qformer_tokenizer() __UpperCAmelCase = InstructBlipProcessor( tokenizer=_lowercase , image_processor=_lowercase , qformer_tokenizer=_lowercase ) __UpperCAmelCase = self.prepare_image_inputs() __UpperCAmelCase = image_processor(_lowercase , return_tensors='''np''' ) __UpperCAmelCase = processor(images=_lowercase , return_tensors='''np''' ) for key in input_feat_extract.keys(): self.assertAlmostEqual(input_feat_extract[key].sum() , input_processor[key].sum() , delta=1E-2 ) def a ( self : Dict ): __UpperCAmelCase = self.get_image_processor() __UpperCAmelCase = self.get_tokenizer() __UpperCAmelCase = self.get_qformer_tokenizer() __UpperCAmelCase = InstructBlipProcessor( tokenizer=_lowercase , image_processor=_lowercase , qformer_tokenizer=_lowercase ) __UpperCAmelCase = '''lower newer''' __UpperCAmelCase = processor(text=_lowercase ) __UpperCAmelCase = tokenizer(_lowercase , return_token_type_ids=_lowercase ) __UpperCAmelCase = qformer_tokenizer(_lowercase , return_token_type_ids=_lowercase ) for key in encoded_tokens.keys(): self.assertListEqual(encoded_tokens[key] , encoded_processor[key] ) for key in encoded_tokens_qformer.keys(): self.assertListEqual(encoded_tokens_qformer[key] , encoded_processor['''qformer_''' + key] ) def a ( self : Union[str, Any] ): __UpperCAmelCase = self.get_image_processor() __UpperCAmelCase = self.get_tokenizer() __UpperCAmelCase = self.get_qformer_tokenizer() __UpperCAmelCase = InstructBlipProcessor( tokenizer=_lowercase , image_processor=_lowercase , qformer_tokenizer=_lowercase ) __UpperCAmelCase = '''lower newer''' __UpperCAmelCase = self.prepare_image_inputs() __UpperCAmelCase = processor(text=_lowercase , images=_lowercase ) self.assertListEqual( list(inputs.keys() ) , ['''input_ids''', '''attention_mask''', '''qformer_input_ids''', '''qformer_attention_mask''', '''pixel_values'''] , ) # test if it raises when no input is passed with pytest.raises(_lowercase ): processor() def a ( self : Any ): __UpperCAmelCase = self.get_image_processor() __UpperCAmelCase = self.get_tokenizer() __UpperCAmelCase = self.get_qformer_tokenizer() __UpperCAmelCase = InstructBlipProcessor( tokenizer=_lowercase , image_processor=_lowercase , qformer_tokenizer=_lowercase ) __UpperCAmelCase = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] __UpperCAmelCase = processor.batch_decode(_lowercase ) __UpperCAmelCase = tokenizer.batch_decode(_lowercase ) self.assertListEqual(_lowercase , _lowercase ) def a ( self : Union[str, Any] ): __UpperCAmelCase = self.get_image_processor() __UpperCAmelCase = self.get_tokenizer() __UpperCAmelCase = self.get_qformer_tokenizer() __UpperCAmelCase = InstructBlipProcessor( tokenizer=_lowercase , image_processor=_lowercase , qformer_tokenizer=_lowercase ) __UpperCAmelCase = '''lower newer''' __UpperCAmelCase = self.prepare_image_inputs() __UpperCAmelCase = processor(text=_lowercase , images=_lowercase ) self.assertListEqual( list(inputs.keys() ) , ['''input_ids''', '''attention_mask''', '''qformer_input_ids''', '''qformer_attention_mask''', '''pixel_values'''] , )
332
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, ) _lowercase : Union[str, Any] = { 'configuration_resnet': ['RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ResNetConfig', 'ResNetOnnxConfig'] } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : int = [ 'RESNET_PRETRAINED_MODEL_ARCHIVE_LIST', 'ResNetForImageClassification', 'ResNetModel', 'ResNetPreTrainedModel', 'ResNetBackbone', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : Union[str, Any] = [ 'TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST', 'TFResNetForImageClassification', 'TFResNetModel', 'TFResNetPreTrainedModel', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : Optional[int] = [ '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 _lowercase : Dict = _LazyModule(__name__, globals()['__file__'], _import_structure)
332
1
"""simple docstring""" from math import pi, sqrt def lowercase__ ( snake_case_ :float ): if num <= 0: raise ValueError('''math domain error''' ) if num > 171.5: raise OverflowError('''math range error''' ) elif num - int(snake_case_ ) not in (0, 0.5): raise NotImplementedError('''num must be an integer or a half-integer''' ) elif num == 0.5: return sqrt(snake_case_ ) else: return 1.0 if num == 1 else (num - 1) * gamma(num - 1 ) def lowercase__ ( ): assert gamma(0.5 ) == sqrt(snake_case_ ) assert gamma(1 ) == 1.0 assert gamma(2 ) == 1.0 if __name__ == "__main__": from doctest import testmod testmod() _lowercase : Any = 1.0 while num: _lowercase : int = float(input('Gamma of: ')) print(f"""gamma({num}) = {gamma(num)}""") print('\nEnter 0 to exit...')
332
"""simple docstring""" _lowercase : Any = '\n# Installazione di Transformers\n! pip install transformers datasets\n# Per installare dalla fonte invece dell\'ultima versione rilasciata, commenta il comando sopra e\n# rimuovi la modalità commento al comando seguente.\n# ! pip install git+https://github.com/huggingface/transformers.git\n' _lowercase : Tuple = [{'type': 'code', 'content': INSTALL_CONTENT}] _lowercase : int = { '{processor_class}': 'FakeProcessorClass', '{model_class}': 'FakeModelClass', '{object_class}': 'FakeObjectClass', }
332
1
"""simple docstring""" from math import pi, sqrt, tan def lowercase__ ( snake_case_ :float ): if side_length < 0: raise ValueError('''surface_area_cube() only accepts non-negative values''' ) return 6 * side_length**2 def lowercase__ ( snake_case_ :float , snake_case_ :float , snake_case_ :float ): if length < 0 or breadth < 0 or height < 0: raise ValueError('''surface_area_cuboid() only accepts non-negative values''' ) return 2 * ((length * breadth) + (breadth * height) + (length * height)) def lowercase__ ( snake_case_ :float ): if radius < 0: raise ValueError('''surface_area_sphere() only accepts non-negative values''' ) return 4 * pi * radius**2 def lowercase__ ( snake_case_ :float ): if radius < 0: raise ValueError('''surface_area_hemisphere() only accepts non-negative values''' ) return 3 * pi * radius**2 def lowercase__ ( snake_case_ :float , snake_case_ :float ): if radius < 0 or height < 0: raise ValueError('''surface_area_cone() only accepts non-negative values''' ) return pi * radius * (radius + (height**2 + radius**2) ** 0.5) def lowercase__ ( snake_case_ :float , snake_case_ :float , snake_case_ :float ): if radius_a < 0 or radius_a < 0 or height < 0: raise ValueError( '''surface_area_conical_frustum() only accepts non-negative values''' ) __UpperCAmelCase = (height**2 + (radius_a - radius_a) ** 2) ** 0.5 return pi * ((slant_height * (radius_a + radius_a)) + radius_a**2 + radius_a**2) def lowercase__ ( snake_case_ :float , snake_case_ :float ): if radius < 0 or height < 0: raise ValueError('''surface_area_cylinder() only accepts non-negative values''' ) return 2 * pi * radius * (height + radius) def lowercase__ ( snake_case_ :float , snake_case_ :float ): if torus_radius < 0 or tube_radius < 0: raise ValueError('''surface_area_torus() only accepts non-negative values''' ) if torus_radius < tube_radius: raise ValueError( '''surface_area_torus() does not support spindle or self intersecting tori''' ) return 4 * pow(snake_case_ , 2 ) * torus_radius * tube_radius def lowercase__ ( snake_case_ :float , snake_case_ :float ): if length < 0 or width < 0: raise ValueError('''area_rectangle() only accepts non-negative values''' ) return length * width def lowercase__ ( snake_case_ :float ): if side_length < 0: raise ValueError('''area_square() only accepts non-negative values''' ) return side_length**2 def lowercase__ ( snake_case_ :float , snake_case_ :float ): if base < 0 or height < 0: raise ValueError('''area_triangle() only accepts non-negative values''' ) return (base * height) / 2 def lowercase__ ( snake_case_ :float , snake_case_ :float , snake_case_ :float ): if sidea < 0 or sidea < 0 or sidea < 0: raise ValueError('''area_triangle_three_sides() only accepts non-negative values''' ) elif sidea + sidea < sidea or sidea + sidea < sidea or sidea + sidea < sidea: raise ValueError('''Given three sides do not form a triangle''' ) __UpperCAmelCase = (sidea + sidea + sidea) / 2 __UpperCAmelCase = sqrt( semi_perimeter * (semi_perimeter - sidea) * (semi_perimeter - sidea) * (semi_perimeter - sidea) ) return area def lowercase__ ( snake_case_ :float , snake_case_ :float ): if base < 0 or height < 0: raise ValueError('''area_parallelogram() only accepts non-negative values''' ) return base * height def lowercase__ ( snake_case_ :float , snake_case_ :float , snake_case_ :float ): if basea < 0 or basea < 0 or height < 0: raise ValueError('''area_trapezium() only accepts non-negative values''' ) return 1 / 2 * (basea + basea) * height def lowercase__ ( snake_case_ :float ): if radius < 0: raise ValueError('''area_circle() only accepts non-negative values''' ) return pi * radius**2 def lowercase__ ( snake_case_ :float , snake_case_ :float ): if radius_x < 0 or radius_y < 0: raise ValueError('''area_ellipse() only accepts non-negative values''' ) return pi * radius_x * radius_y def lowercase__ ( snake_case_ :float , snake_case_ :float ): if diagonal_a < 0 or diagonal_a < 0: raise ValueError('''area_rhombus() only accepts non-negative values''' ) return 1 / 2 * diagonal_a * diagonal_a def lowercase__ ( snake_case_ :int , snake_case_ :float ): if not isinstance(snake_case_ , snake_case_ ) or sides < 3: raise ValueError( '''area_reg_polygon() only accepts integers greater than or \ equal to three as number of sides''' ) elif length < 0: raise ValueError( '''area_reg_polygon() only accepts non-negative values as \ length of a side''' ) return (sides * length**2) / (4 * tan(pi / sides )) return (sides * length**2) / (4 * tan(pi / sides )) if __name__ == "__main__": import doctest doctest.testmod(verbose=True) # verbose so we can see methods missing tests print('[DEMO] Areas of various geometric shapes: \n') print(f"""Rectangle: {area_rectangle(10, 20) = }""") print(f"""Square: {area_square(10) = }""") print(f"""Triangle: {area_triangle(10, 10) = }""") print(f"""Triangle: {area_triangle_three_sides(5, 12, 13) = }""") print(f"""Parallelogram: {area_parallelogram(10, 20) = }""") print(f"""Rhombus: {area_rhombus(10, 20) = }""") print(f"""Trapezium: {area_trapezium(10, 20, 30) = }""") print(f"""Circle: {area_circle(20) = }""") print(f"""Ellipse: {area_ellipse(10, 20) = }""") print('\nSurface Areas of various geometric shapes: \n') print(f"""Cube: {surface_area_cube(20) = }""") print(f"""Cuboid: {surface_area_cuboid(10, 20, 30) = }""") print(f"""Sphere: {surface_area_sphere(20) = }""") print(f"""Hemisphere: {surface_area_hemisphere(20) = }""") print(f"""Cone: {surface_area_cone(10, 20) = }""") print(f"""Conical Frustum: {surface_area_conical_frustum(10, 20, 30) = }""") print(f"""Cylinder: {surface_area_cylinder(10, 20) = }""") print(f"""Torus: {surface_area_torus(20, 10) = }""") print(f"""Equilateral Triangle: {area_reg_polygon(3, 10) = }""") print(f"""Square: {area_reg_polygon(4, 10) = }""") print(f"""Reqular Pentagon: {area_reg_polygon(5, 10) = }""")
332
"""simple docstring""" import importlib.util import os import platform from argparse import ArgumentParser import huggingface_hub from .. import __version__ as version from ..utils import ( is_accelerate_available, is_flax_available, is_safetensors_available, is_tf_available, is_torch_available, ) from . import BaseTransformersCLICommand def lowercase__ ( snake_case_ :Optional[int] ): return EnvironmentCommand() def lowercase__ ( snake_case_ :List[str] ): return EnvironmentCommand(args.accelerate_config_file ) class _UpperCAmelCase ( _lowerCAmelCase ): @staticmethod def a ( _lowercase : ArgumentParser ): __UpperCAmelCase = parser.add_parser('''env''' ) download_parser.set_defaults(func=_lowercase ) download_parser.add_argument( '''--accelerate-config_file''' , default=_lowercase , help='''The accelerate config file to use for the default values in the launching script.''' , ) download_parser.set_defaults(func=_lowercase ) def __init__( self : Optional[int] , _lowercase : str , *_lowercase : Tuple ): __UpperCAmelCase = accelerate_config_file def a ( self : Dict ): __UpperCAmelCase = '''not installed''' if is_safetensors_available(): import safetensors __UpperCAmelCase = safetensors.__version__ elif importlib.util.find_spec('''safetensors''' ) is not None: import safetensors __UpperCAmelCase = F'''{safetensors.__version__} but is ignored because of PyTorch version too old.''' __UpperCAmelCase = '''not installed''' __UpperCAmelCase = __UpperCAmelCase = '''not found''' if is_accelerate_available(): import accelerate from accelerate.commands.config import default_config_file, load_config_from_file __UpperCAmelCase = accelerate.__version__ # Get the default from the config file. if self._accelerate_config_file is not None or os.path.isfile(_lowercase ): __UpperCAmelCase = load_config_from_file(self._accelerate_config_file ).to_dict() __UpperCAmelCase = ( '''\n'''.join([F'''\t- {prop}: {val}''' for prop, val in accelerate_config.items()] ) if isinstance(_lowercase , _lowercase ) else F'''\t{accelerate_config}''' ) __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''NA''' if is_torch_available(): import torch __UpperCAmelCase = torch.__version__ __UpperCAmelCase = torch.cuda.is_available() __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''NA''' if is_tf_available(): import tensorflow as tf __UpperCAmelCase = tf.__version__ try: # deprecated in v2.1 __UpperCAmelCase = tf.test.is_gpu_available() except AttributeError: # returns list of devices, convert to bool __UpperCAmelCase = bool(tf.config.list_physical_devices('''GPU''' ) ) __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''NA''' if is_flax_available(): import flax import jax import jaxlib __UpperCAmelCase = flax.__version__ __UpperCAmelCase = jax.__version__ __UpperCAmelCase = jaxlib.__version__ __UpperCAmelCase = jax.lib.xla_bridge.get_backend().platform __UpperCAmelCase = { '''`transformers` version''': version, '''Platform''': platform.platform(), '''Python version''': platform.python_version(), '''Huggingface_hub version''': huggingface_hub.__version__, '''Safetensors version''': F'''{safetensors_version}''', '''Accelerate version''': F'''{accelerate_version}''', '''Accelerate config''': F'''{accelerate_config_str}''', '''PyTorch version (GPU?)''': F'''{pt_version} ({pt_cuda_available})''', '''Tensorflow version (GPU?)''': F'''{tf_version} ({tf_cuda_available})''', '''Flax version (CPU?/GPU?/TPU?)''': F'''{flax_version} ({jax_backend})''', '''Jax version''': F'''{jax_version}''', '''JaxLib version''': F'''{jaxlib_version}''', '''Using GPU in script?''': '''<fill in>''', '''Using distributed or parallel set-up in script?''': '''<fill in>''', } print('''\nCopy-and-paste the text below in your GitHub issue and FILL OUT the two last points.\n''' ) print(self.format_dict(_lowercase ) ) return info @staticmethod def a ( _lowercase : str ): return "\n".join([F'''- {prop}: {val}''' for prop, val in d.items()] ) + "\n"
332
1
"""simple docstring""" import os from datetime import datetime as dt from github import Github _lowercase : Optional[int] = [ 'good first issue', 'good second issue', 'good difficult issue', 'enhancement', 'new pipeline/model', 'new scheduler', 'wip', ] def lowercase__ ( ): __UpperCAmelCase = Github(os.environ['''GITHUB_TOKEN'''] ) __UpperCAmelCase = g.get_repo('''huggingface/diffusers''' ) __UpperCAmelCase = repo.get_issues(state='''open''' ) for issue in open_issues: __UpperCAmelCase = sorted(issue.get_comments() , key=lambda snake_case_ : i.created_at , reverse=snake_case_ ) __UpperCAmelCase = comments[0] if len(snake_case_ ) > 0 else None if ( last_comment is not None and last_comment.user.login == "github-actions[bot]" and (dt.utcnow() - issue.updated_at).days > 7 and (dt.utcnow() - issue.created_at).days >= 30 and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels() ) ): # Closes the issue after 7 days of inactivity since the Stalebot notification. issue.edit(state='''closed''' ) elif ( "stale" in issue.get_labels() and last_comment is not None and last_comment.user.login != "github-actions[bot]" ): # Opens the issue if someone other than Stalebot commented. issue.edit(state='''open''' ) issue.remove_from_labels('''stale''' ) elif ( (dt.utcnow() - issue.updated_at).days > 23 and (dt.utcnow() - issue.created_at).days >= 30 and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels() ) ): # Post a Stalebot notification after 23 days of inactivity. issue.create_comment( '''This issue has been automatically marked as stale because it has not had ''' '''recent activity. If you think this still needs to be addressed ''' '''please comment on this thread.\n\nPlease note that issues that do not follow the ''' '''[contributing guidelines](https://github.com/huggingface/diffusers/blob/main/CONTRIBUTING.md) ''' '''are likely to be ignored.''' ) issue.add_to_labels('''stale''' ) if __name__ == "__main__": main()
332
"""simple docstring""" from __future__ import annotations def lowercase__ ( snake_case_ :list[float] , snake_case_ :list[float] ): __UpperCAmelCase = sorted(numsa + numsa ) __UpperCAmelCase , __UpperCAmelCase = divmod(len(snake_case_ ) , 2 ) if mod == 1: return all_numbers[div] else: return (all_numbers[div] + all_numbers[div - 1]) / 2 if __name__ == "__main__": import doctest doctest.testmod() _lowercase : int = [float(x) for x in input('Enter the elements of first array: ').split()] _lowercase : Tuple = [float(x) for x in input('Enter the elements of second array: ').split()] print(f"""The median of two arrays is: {median_of_two_arrays(array_a, array_a)}""")
332
1
"""simple docstring""" def lowercase__ ( snake_case_ :str ): __UpperCAmelCase = len(snake_case_ ) while cur > 1: # Find the maximum number in arr __UpperCAmelCase = arr.index(max(arr[0:cur] ) ) # Reverse from 0 to mi __UpperCAmelCase = arr[mi::-1] + arr[mi + 1 : len(snake_case_ )] # Reverse whole list __UpperCAmelCase = arr[cur - 1 :: -1] + arr[cur : len(snake_case_ )] cur -= 1 return arr if __name__ == "__main__": _lowercase : Optional[int] = input('Enter numbers separated by a comma:\n').strip() _lowercase : Dict = [int(item) for item in user_input.split(',')] print(pancake_sort(unsorted))
332
"""simple docstring""" import heapq as hq import math from collections.abc import Iterator class _UpperCAmelCase : def __init__( self : Union[str, Any] , _lowercase : Optional[Any] ): __UpperCAmelCase = str(id_ ) __UpperCAmelCase = None __UpperCAmelCase = None __UpperCAmelCase = [] __UpperCAmelCase = {} # {vertex:distance} def __lt__( self : str , _lowercase : List[Any] ): return self.key < other.key def __repr__( self : int ): return self.id def a ( self : Union[str, Any] , _lowercase : int ): self.neighbors.append(_lowercase ) def a ( self : List[Any] , _lowercase : Optional[Any] , _lowercase : int ): __UpperCAmelCase = weight def lowercase__ ( snake_case_ :int , snake_case_ :Any , snake_case_ :Union[str, Any] , snake_case_ :List[str] ): # add the neighbors: graph[a - 1].add_neighbor(graph[b - 1] ) graph[b - 1].add_neighbor(graph[a - 1] ) # add the edges: graph[a - 1].add_edge(graph[b - 1] , snake_case_ ) graph[b - 1].add_edge(graph[a - 1] , snake_case_ ) def lowercase__ ( snake_case_ :list , snake_case_ :Vertex ): __UpperCAmelCase = [] for u in graph: __UpperCAmelCase = math.inf __UpperCAmelCase = None __UpperCAmelCase = 0 __UpperCAmelCase = graph[:] while q: __UpperCAmelCase = min(snake_case_ ) q.remove(snake_case_ ) for v in u.neighbors: if (v in q) and (u.edges[v.id] < v.key): __UpperCAmelCase = u __UpperCAmelCase = u.edges[v.id] for i in range(1 , len(snake_case_ ) ): a.append((int(graph[i].id ) + 1, int(graph[i].pi.id ) + 1) ) return a def lowercase__ ( snake_case_ :list , snake_case_ :Vertex ): for u in graph: __UpperCAmelCase = math.inf __UpperCAmelCase = None __UpperCAmelCase = 0 __UpperCAmelCase = list(snake_case_ ) hq.heapify(snake_case_ ) while h: __UpperCAmelCase = hq.heappop(snake_case_ ) for v in u.neighbors: if (v in h) and (u.edges[v.id] < v.key): __UpperCAmelCase = u __UpperCAmelCase = u.edges[v.id] hq.heapify(snake_case_ ) for i in range(1 , len(snake_case_ ) ): yield (int(graph[i].id ) + 1, int(graph[i].pi.id ) + 1) def lowercase__ ( ): pass if __name__ == "__main__": import doctest doctest.testmod()
332
1
"""simple docstring""" import heapq import sys import numpy as np _lowercase : Union[str, Any] = tuple[int, int] class _UpperCAmelCase : def __init__( self : str ): __UpperCAmelCase = [] __UpperCAmelCase = set() def a ( self : Dict ): if not self.empty(): return self.elements[0][0] else: return float('''inf''' ) def a ( self : str ): return len(self.elements ) == 0 def a ( self : Union[str, Any] , _lowercase : Tuple , _lowercase : Dict ): if item not in self.set: heapq.heappush(self.elements , (priority, item) ) self.set.add(_lowercase ) else: # update # print("update", item) __UpperCAmelCase = [] ((__UpperCAmelCase) , (__UpperCAmelCase)) = heapq.heappop(self.elements ) while x != item: temp.append((pri, x) ) ((__UpperCAmelCase) , (__UpperCAmelCase)) = heapq.heappop(self.elements ) temp.append((priority, item) ) for pro, xxx in temp: heapq.heappush(self.elements , (pro, xxx) ) def a ( self : Tuple , _lowercase : int ): if item in self.set: self.set.remove(_lowercase ) __UpperCAmelCase = [] ((__UpperCAmelCase) , (__UpperCAmelCase)) = heapq.heappop(self.elements ) while x != item: temp.append((pro, x) ) ((__UpperCAmelCase) , (__UpperCAmelCase)) = heapq.heappop(self.elements ) for prito, yyy in temp: heapq.heappush(self.elements , (prito, yyy) ) def a ( self : str ): return self.elements[0][1] def a ( self : List[Any] ): ((__UpperCAmelCase) , (__UpperCAmelCase)) = heapq.heappop(self.elements ) self.set.remove(_lowercase ) return (priority, item) def lowercase__ ( snake_case_ :TPos , snake_case_ :TPos ): # euclidean distance __UpperCAmelCase = np.array(snake_case_ ) __UpperCAmelCase = np.array(snake_case_ ) return np.linalg.norm(a - b ) def lowercase__ ( snake_case_ :TPos , snake_case_ :TPos ): # integer division by time variable return consistent_heuristic(snake_case_ , snake_case_ ) // t def lowercase__ ( snake_case_ :TPos , snake_case_ :TPos ): # manhattan distance return abs(p[0] - goal[0] ) + abs(p[1] - goal[1] ) def lowercase__ ( snake_case_ :TPos , snake_case_ :int , snake_case_ :TPos , snake_case_ :dict[TPos, float] ): __UpperCAmelCase = g_function[start] + Wa * heuristics[i](snake_case_ , snake_case_ ) return ans def lowercase__ ( snake_case_ :Any , snake_case_ :Union[str, Any] , snake_case_ :Tuple ): __UpperCAmelCase = np.chararray((n, n) ) for i in range(snake_case_ ): for j in range(snake_case_ ): __UpperCAmelCase = '''*''' for i in range(snake_case_ ): for j in range(snake_case_ ): if (j, (n - 1) - i) in blocks: __UpperCAmelCase = '''#''' __UpperCAmelCase = '''-''' __UpperCAmelCase = back_pointer[goal] while x != start: ((__UpperCAmelCase) , (__UpperCAmelCase)) = x # print(x) __UpperCAmelCase = '''-''' __UpperCAmelCase = back_pointer[x] __UpperCAmelCase = '''-''' for i in range(snake_case_ ): for j in range(snake_case_ ): if (i, j) == (0, n - 1): print(grid[i][j] , end=''' ''' ) print('''<-- End position''' , end=''' ''' ) else: print(grid[i][j] , end=''' ''' ) print() print('''^''' ) print('''Start position''' ) print() print('''# is an obstacle''' ) print('''- is the path taken by algorithm''' ) print('''PATH TAKEN BY THE ALGORITHM IS:-''' ) __UpperCAmelCase = back_pointer[goal] while x != start: print(snake_case_ , end=''' ''' ) __UpperCAmelCase = back_pointer[x] print(snake_case_ ) sys.exit() def lowercase__ ( snake_case_ :TPos ): if p[0] < 0 or p[0] > n - 1: return False if p[1] < 0 or p[1] > n - 1: return False return True def lowercase__ ( snake_case_ :Tuple , snake_case_ :Dict , snake_case_ :Any , snake_case_ :List[str] , snake_case_ :Union[str, Any] , snake_case_ :List[Any] , snake_case_ :Tuple , snake_case_ :Any , ): for itera in range(snake_case_ ): open_list[itera].remove_element(snake_case_ ) # print("s", s) # print("j", j) ((__UpperCAmelCase) , (__UpperCAmelCase)) = s __UpperCAmelCase = (x - 1, y) __UpperCAmelCase = (x + 1, y) __UpperCAmelCase = (x, y + 1) __UpperCAmelCase = (x, y - 1) for neighbours in [left, right, up, down]: if neighbours not in blocks: if valid(snake_case_ ) and neighbours not in visited: # print("neighbour", neighbours) visited.add(snake_case_ ) __UpperCAmelCase = -1 __UpperCAmelCase = float('''inf''' ) if valid(snake_case_ ) and g_function[neighbours] > g_function[s] + 1: __UpperCAmelCase = g_function[s] + 1 __UpperCAmelCase = s if neighbours not in close_list_anchor: open_list[0].put(snake_case_ , key(snake_case_ , 0 , snake_case_ , snake_case_ ) ) if neighbours not in close_list_inad: for var in range(1 , snake_case_ ): if key(snake_case_ , snake_case_ , snake_case_ , snake_case_ ) <= Wa * key( snake_case_ , 0 , snake_case_ , snake_case_ ): open_list[j].put( snake_case_ , key(snake_case_ , snake_case_ , snake_case_ , snake_case_ ) ) def lowercase__ ( ): __UpperCAmelCase = [] for x in range(1 , 5 ): for y in range(1 , 6 ): some_list.append((x, y) ) for x in range(15 , 20 ): some_list.append((x, 17) ) for x in range(10 , 19 ): for y in range(1 , 15 ): some_list.append((x, y) ) # L block for x in range(1 , 4 ): for y in range(12 , 19 ): some_list.append((x, y) ) for x in range(3 , 13 ): for y in range(16 , 19 ): some_list.append((x, y) ) return some_list _lowercase : Dict = {0: consistent_heuristic, 1: heuristic_a, 2: heuristic_a} _lowercase : Dict = [ (0, 1), (1, 1), (2, 1), (3, 1), (4, 1), (5, 1), (6, 1), (7, 1), (8, 1), (9, 1), (10, 1), (11, 1), (12, 1), (13, 1), (14, 1), (15, 1), (16, 1), (17, 1), (18, 1), (19, 1), ] _lowercase : Tuple = make_common_ground() _lowercase : int = blocks_blk # hyper parameters _lowercase : List[str] = 1 _lowercase : Any = 1 _lowercase : Optional[int] = 20 _lowercase : Tuple = 3 # one consistent and two other inconsistent # start and end destination _lowercase : Union[str, Any] = (0, 0) _lowercase : Tuple = (n - 1, n - 1) _lowercase : int = 1 def lowercase__ ( snake_case_ :TPos , snake_case_ :TPos , snake_case_ :int ): __UpperCAmelCase = {start: 0, goal: float('''inf''' )} __UpperCAmelCase = {start: -1, goal: -1} __UpperCAmelCase = [] __UpperCAmelCase = set() for i in range(snake_case_ ): open_list.append(PriorityQueue() ) open_list[i].put(snake_case_ , key(snake_case_ , snake_case_ , snake_case_ , snake_case_ ) ) __UpperCAmelCase = [] __UpperCAmelCase = [] while open_list[0].minkey() < float('''inf''' ): for i in range(1 , snake_case_ ): # print(open_list[0].minkey(), open_list[i].minkey()) if open_list[i].minkey() <= Wa * open_list[0].minkey(): global t t += 1 if g_function[goal] <= open_list[i].minkey(): if g_function[goal] < float('''inf''' ): do_something(snake_case_ , snake_case_ , snake_case_ ) else: __UpperCAmelCase , __UpperCAmelCase = open_list[i].top_show() visited.add(snake_case_ ) expand_state( snake_case_ , snake_case_ , snake_case_ , snake_case_ , snake_case_ , snake_case_ , snake_case_ , snake_case_ , ) close_list_inad.append(snake_case_ ) else: if g_function[goal] <= open_list[0].minkey(): if g_function[goal] < float('''inf''' ): do_something(snake_case_ , snake_case_ , snake_case_ ) else: __UpperCAmelCase = open_list[0].top_show() visited.add(snake_case_ ) expand_state( snake_case_ , 0 , snake_case_ , snake_case_ , snake_case_ , snake_case_ , snake_case_ , snake_case_ , ) close_list_anchor.append(snake_case_ ) print('''No path found to goal''' ) print() for i in range(n - 1 , -1 , -1 ): for j in range(snake_case_ ): if (j, i) in blocks: print('''#''' , end=''' ''' ) elif (j, i) in back_pointer: if (j, i) == (n - 1, n - 1): print('''*''' , end=''' ''' ) else: print('''-''' , end=''' ''' ) else: print('''*''' , end=''' ''' ) if (j, i) == (n - 1, n - 1): print('''<-- End position''' , end=''' ''' ) print() print('''^''' ) print('''Start position''' ) print() print('''# is an obstacle''' ) print('''- is the path taken by algorithm''' ) if __name__ == "__main__": multi_a_star(start, goal, n_heuristic)
332
"""simple docstring""" from ...configuration_utils import PretrainedConfig from ...utils import logging _lowercase : str = logging.get_logger(__name__) _lowercase : Dict = { 'microsoft/swinv2-tiny-patch4-window8-256': ( 'https://huggingface.co/microsoft/swinv2-tiny-patch4-window8-256/resolve/main/config.json' ), } class _UpperCAmelCase ( _lowerCAmelCase ): a__ : Tuple = "swinv2" a__ : List[Any] = { "num_attention_heads": "num_heads", "num_hidden_layers": "num_layers", } def __init__( self : Any , _lowercase : List[Any]=2_24 , _lowercase : int=4 , _lowercase : Optional[int]=3 , _lowercase : Optional[Any]=96 , _lowercase : Optional[int]=[2, 2, 6, 2] , _lowercase : Optional[int]=[3, 6, 12, 24] , _lowercase : str=7 , _lowercase : Union[str, Any]=4.0 , _lowercase : List[str]=True , _lowercase : List[Any]=0.0 , _lowercase : Dict=0.0 , _lowercase : List[Any]=0.1 , _lowercase : Union[str, Any]="gelu" , _lowercase : Tuple=False , _lowercase : Optional[int]=0.02 , _lowercase : List[Any]=1E-5 , _lowercase : Tuple=32 , **_lowercase : Optional[int] , ): super().__init__(**_lowercase ) __UpperCAmelCase = image_size __UpperCAmelCase = patch_size __UpperCAmelCase = num_channels __UpperCAmelCase = embed_dim __UpperCAmelCase = depths __UpperCAmelCase = len(_lowercase ) __UpperCAmelCase = num_heads __UpperCAmelCase = window_size __UpperCAmelCase = mlp_ratio __UpperCAmelCase = qkv_bias __UpperCAmelCase = hidden_dropout_prob __UpperCAmelCase = attention_probs_dropout_prob __UpperCAmelCase = drop_path_rate __UpperCAmelCase = hidden_act __UpperCAmelCase = use_absolute_embeddings __UpperCAmelCase = layer_norm_eps __UpperCAmelCase = initializer_range __UpperCAmelCase = encoder_stride # we set the hidden_size attribute in order to make Swinv2 work with VisionEncoderDecoderModel # this indicates the channel dimension after the last stage of the model __UpperCAmelCase = int(embed_dim * 2 ** (len(_lowercase ) - 1) ) __UpperCAmelCase = (0, 0, 0, 0)
332
1
"""simple docstring""" def lowercase__ ( snake_case_ :int ): __UpperCAmelCase = (1 + 24 * n) ** 0.5 return ((1 + root) / 6) % 1 == 0 def lowercase__ ( snake_case_ :int = 5_000 ): __UpperCAmelCase = [(i * (3 * i - 1)) // 2 for i in range(1 , snake_case_ )] for i, pentagonal_i in enumerate(snake_case_ ): for j in range(snake_case_ , len(snake_case_ ) ): __UpperCAmelCase = pentagonal_nums[j] __UpperCAmelCase = pentagonal_i + pentagonal_j __UpperCAmelCase = pentagonal_j - pentagonal_i if is_pentagonal(snake_case_ ) and is_pentagonal(snake_case_ ): return b return -1 if __name__ == "__main__": print(f"""{solution() = }""")
332
"""simple docstring""" import pprint import requests _lowercase : Optional[Any] = 'https://zenquotes.io/api' def lowercase__ ( ): return requests.get(API_ENDPOINT_URL + '''/today''' ).json() def lowercase__ ( ): return requests.get(API_ENDPOINT_URL + '''/random''' ).json() if __name__ == "__main__": _lowercase : int = random_quotes() pprint.pprint(response)
332
1
"""simple docstring""" import re import jax.numpy as jnp from flax.traverse_util import flatten_dict, unflatten_dict from jax.random import PRNGKey from ..utils import logging _lowercase : int = logging.get_logger(__name__) def lowercase__ ( snake_case_ :Any ): __UpperCAmelCase = r'''\w+[.]\d+''' __UpperCAmelCase = re.findall(snake_case_ , snake_case_ ) for pat in pats: __UpperCAmelCase = key.replace(snake_case_ , '''_'''.join(pat.split('''.''' ) ) ) return key def lowercase__ ( snake_case_ :str , snake_case_ :Any , snake_case_ :List[str] ): __UpperCAmelCase = pt_tuple_key[:-1] + ('''scale''',) if ( any('''norm''' in str_ for str_ in pt_tuple_key ) and (pt_tuple_key[-1] == "bias") and (pt_tuple_key[:-1] + ("bias",) not in random_flax_state_dict) and (pt_tuple_key[:-1] + ("scale",) in random_flax_state_dict) ): __UpperCAmelCase = pt_tuple_key[:-1] + ('''scale''',) return renamed_pt_tuple_key, pt_tensor elif pt_tuple_key[-1] in ["weight", "gamma"] and pt_tuple_key[:-1] + ("scale",) in random_flax_state_dict: __UpperCAmelCase = pt_tuple_key[:-1] + ('''scale''',) return renamed_pt_tuple_key, pt_tensor # embedding if pt_tuple_key[-1] == "weight" and pt_tuple_key[:-1] + ("embedding",) in random_flax_state_dict: __UpperCAmelCase = pt_tuple_key[:-1] + ('''embedding''',) return renamed_pt_tuple_key, pt_tensor # conv layer __UpperCAmelCase = pt_tuple_key[:-1] + ('''kernel''',) if pt_tuple_key[-1] == "weight" and pt_tensor.ndim == 4: __UpperCAmelCase = pt_tensor.transpose(2 , 3 , 1 , 0 ) return renamed_pt_tuple_key, pt_tensor # linear layer __UpperCAmelCase = pt_tuple_key[:-1] + ('''kernel''',) if pt_tuple_key[-1] == "weight": __UpperCAmelCase = pt_tensor.T return renamed_pt_tuple_key, pt_tensor # old PyTorch layer norm weight __UpperCAmelCase = pt_tuple_key[:-1] + ('''weight''',) if pt_tuple_key[-1] == "gamma": return renamed_pt_tuple_key, pt_tensor # old PyTorch layer norm bias __UpperCAmelCase = pt_tuple_key[:-1] + ('''bias''',) if pt_tuple_key[-1] == "beta": return renamed_pt_tuple_key, pt_tensor return pt_tuple_key, pt_tensor def lowercase__ ( snake_case_ :List[Any] , snake_case_ :Dict , snake_case_ :int=42 ): # Step 1: Convert pytorch tensor to numpy __UpperCAmelCase = {k: v.numpy() for k, v in pt_state_dict.items()} # Step 2: Since the model is stateless, get random Flax params __UpperCAmelCase = flax_model.init_weights(PRNGKey(snake_case_ ) ) __UpperCAmelCase = flatten_dict(snake_case_ ) __UpperCAmelCase = {} # Need to change some parameters name to match Flax names for pt_key, pt_tensor in pt_state_dict.items(): __UpperCAmelCase = rename_key(snake_case_ ) __UpperCAmelCase = tuple(renamed_pt_key.split('''.''' ) ) # Correctly rename weight parameters __UpperCAmelCase , __UpperCAmelCase = rename_key_and_reshape_tensor(snake_case_ , snake_case_ , snake_case_ ) if flax_key in random_flax_state_dict: if flax_tensor.shape != random_flax_state_dict[flax_key].shape: raise ValueError( F'''PyTorch checkpoint seems to be incorrect. Weight {pt_key} was expected to be of shape ''' F'''{random_flax_state_dict[flax_key].shape}, but is {flax_tensor.shape}.''' ) # also add unexpected weight so that warning is thrown __UpperCAmelCase = jnp.asarray(snake_case_ ) return unflatten_dict(snake_case_ )
332
"""simple docstring""" from typing import List, Optional, Union import numpy as np import tensorflow as tf from .utils import logging _lowercase : List[str] = logging.get_logger(__name__) def lowercase__ ( snake_case_ :Union[tf.Tensor, np.ndarray] ): if isinstance(snake_case_ , np.ndarray ): return list(tensor.shape ) __UpperCAmelCase = tf.shape(snake_case_ ) if tensor.shape == tf.TensorShape(snake_case_ ): return dynamic __UpperCAmelCase = tensor.shape.as_list() return [dynamic[i] if s is None else s for i, s in enumerate(snake_case_ )] def lowercase__ ( snake_case_ :tf.Tensor , snake_case_ :Optional[int] = None , snake_case_ :Optional[str] = None ): return tf.nn.softmax(logits=logits + 1E-9 , axis=snake_case_ , name=snake_case_ ) def lowercase__ ( snake_case_ :int , snake_case_ :Union[str, Any] , snake_case_ :str , snake_case_ :Union[str, Any]=1E-5 , snake_case_ :List[str]=-1 ): # This is a very simplified functional layernorm, designed to duplicate # the functionality of PyTorch nn.functional.layer_norm when this is needed to port # models in Transformers. if weight.shape.rank != 1 or bias.shape.rank != 1 or not isinstance(snake_case_ , snake_case_ ): raise NotImplementedError('''Only 1D weight and bias tensors are supported for now, with only a single axis.''' ) # Get mean and variance on the axis to be normalized __UpperCAmelCase , __UpperCAmelCase = tf.nn.moments(snake_case_ , axes=[axis] , keepdims=snake_case_ ) if axis != -1: # Reshape scale and weight to have the same rank as inputs, but with 1 dimensions # on every dimension except axis __UpperCAmelCase = [1] * inputs.shape.rank __UpperCAmelCase = shape_list(snake_case_ )[axis] __UpperCAmelCase = tf.reshape(snake_case_ , snake_case_ ) __UpperCAmelCase = tf.reshape(snake_case_ , snake_case_ ) # Compute layer normalization using the batch_normalization # function. __UpperCAmelCase = tf.nn.batch_normalization( snake_case_ , snake_case_ , snake_case_ , offset=snake_case_ , scale=snake_case_ , variance_epsilon=snake_case_ , ) return outputs def lowercase__ ( snake_case_ :Optional[int] , snake_case_ :List[str]=0 , snake_case_ :Optional[Any]=-1 ): # Replicates the behavior of torch.flatten in TF # If end_dim or start_dim is negative, count them from the end if end_dim < 0: end_dim += input.shape.rank if start_dim < 0: start_dim += input.shape.rank if start_dim == end_dim: return input __UpperCAmelCase = tf.shape(snake_case_ ) __UpperCAmelCase = tf.math.reduce_prod(in_shape[start_dim : end_dim + 1] ) __UpperCAmelCase = tf.concat([in_shape[:start_dim], [flattened_dim], in_shape[end_dim + 1 :]] , axis=0 ) return tf.reshape(snake_case_ , snake_case_ ) def lowercase__ ( snake_case_ :tf.Tensor ): if not isinstance(snake_case_ , tf.Tensor ): __UpperCAmelCase = tf.convert_to_tensor(snake_case_ ) # Catches stray NumPy inputs if encoder_attention_mask.shape.rank == 3: __UpperCAmelCase = encoder_attention_mask[:, None, :, :] if encoder_attention_mask.shape.rank == 2: __UpperCAmelCase = encoder_attention_mask[:, None, None, :] # T5 has a mask that can compare sequence ids, we can simulate this here with this transposition # Cf. https://github.com/tensorflow/mesh/blob/8d2465e9bc93129b913b5ccc6a59aa97abd96ec6/mesh_tensorflow # /transformer/transformer_layers.py#L270 # encoder_extended_attention_mask = (encoder_extended_attention_mask == # encoder_extended_attention_mask.transpose(-1, -2)) __UpperCAmelCase = ( tf.cast(1 , encoder_attention_mask.dtype ) - encoder_extended_attention_mask ) * encoder_extended_attention_mask.dtype.min return encoder_extended_attention_mask def lowercase__ ( snake_case_ :tf.Tensor , snake_case_ :int , snake_case_ :str = "input_ids" ): tf.debugging.assert_less( snake_case_ , tf.cast(snake_case_ , dtype=tensor.dtype ) , message=( F'''The maximum value of {tensor_name} ({tf.math.reduce_max(snake_case_ )}) must be smaller than the embedding ''' F'''layer\'s input dimension ({embed_dim}). The likely cause is some problem at tokenization time.''' ) , ) def lowercase__ ( snake_case_ :List[Any] , snake_case_ :List[Any] , snake_case_ :List[str] ): __UpperCAmelCase = 64_512 # Check that no item in `data` is larger than `HDF5_OBJECT_HEADER_LIMIT` # because in that case even chunking the array would not make the saving # possible. __UpperCAmelCase = [x for x in data if len(snake_case_ ) > HDF5_OBJECT_HEADER_LIMIT] # Expecting this to never be true. if bad_attributes: raise RuntimeError( '''The following attributes cannot be saved to HDF5 file because ''' F'''they are larger than {HDF5_OBJECT_HEADER_LIMIT} ''' F'''bytes: {bad_attributes}''' ) __UpperCAmelCase = np.asarray(snake_case_ ) __UpperCAmelCase = 1 __UpperCAmelCase = np.array_split(snake_case_ , snake_case_ ) # This will never loop forever thanks to the test above. while any(x.nbytes > HDF5_OBJECT_HEADER_LIMIT for x in chunked_data ): num_chunks += 1 __UpperCAmelCase = np.array_split(snake_case_ , snake_case_ ) if num_chunks > 1: for chunk_id, chunk_data in enumerate(snake_case_ ): __UpperCAmelCase = chunk_data else: __UpperCAmelCase = data def lowercase__ ( snake_case_ :str , snake_case_ :List[str] ): if name in group.attrs: __UpperCAmelCase = [n.decode('''utf8''' ) if hasattr(snake_case_ , '''decode''' ) else n for n in group.attrs[name]] else: __UpperCAmelCase = [] __UpperCAmelCase = 0 while "%s%d" % (name, chunk_id) in group.attrs: data.extend( [n.decode('''utf8''' ) if hasattr(snake_case_ , '''decode''' ) else n for n in group.attrs['''%s%d''' % (name, chunk_id)]] ) chunk_id += 1 return data def lowercase__ ( snake_case_ :Tuple ): def _expand_single_ad_tensor(snake_case_ :Optional[int] ): if isinstance(snake_case_ , tf.Tensor ) and t.shape.rank == 1: return tf.expand_dims(snake_case_ , axis=-1 ) return t return tf.nest.map_structure(_expand_single_ad_tensor , snake_case_ )
332
1
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_tf_available, is_tokenizers_available, is_torch_available, ) _lowercase : Optional[Any] = {'configuration_xlnet': ['XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP', 'XLNetConfig']} try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : str = ['XLNetTokenizer'] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : Optional[Any] = ['XLNetTokenizerFast'] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : str = [ 'XLNET_PRETRAINED_MODEL_ARCHIVE_LIST', 'XLNetForMultipleChoice', 'XLNetForQuestionAnswering', 'XLNetForQuestionAnsweringSimple', 'XLNetForSequenceClassification', 'XLNetForTokenClassification', 'XLNetLMHeadModel', 'XLNetModel', 'XLNetPreTrainedModel', 'load_tf_weights_in_xlnet', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : Any = [ 'TF_XLNET_PRETRAINED_MODEL_ARCHIVE_LIST', 'TFXLNetForMultipleChoice', 'TFXLNetForQuestionAnsweringSimple', 'TFXLNetForSequenceClassification', 'TFXLNetForTokenClassification', 'TFXLNetLMHeadModel', 'TFXLNetMainLayer', 'TFXLNetModel', 'TFXLNetPreTrainedModel', ] if TYPE_CHECKING: from .configuration_xlnet import XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, XLNetConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_xlnet import XLNetTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_xlnet_fast import XLNetTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_xlnet import ( XLNET_PRETRAINED_MODEL_ARCHIVE_LIST, XLNetForMultipleChoice, XLNetForQuestionAnswering, XLNetForQuestionAnsweringSimple, XLNetForSequenceClassification, XLNetForTokenClassification, XLNetLMHeadModel, XLNetModel, XLNetPreTrainedModel, load_tf_weights_in_xlnet, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_xlnet import ( TF_XLNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFXLNetForMultipleChoice, TFXLNetForQuestionAnsweringSimple, TFXLNetForSequenceClassification, TFXLNetForTokenClassification, TFXLNetLMHeadModel, TFXLNetMainLayer, TFXLNetModel, TFXLNetPreTrainedModel, ) else: import sys _lowercase : List[str] = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
332
"""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 lowercase__ ( snake_case_ :Union[str, Any]=None ): if subparsers is not None: __UpperCAmelCase = subparsers.add_parser('''env''' ) else: __UpperCAmelCase = argparse.ArgumentParser('''Accelerate env command''' ) parser.add_argument( '''--config_file''' , default=snake_case_ , help='''The config file to use for the default values in the launching script.''' ) if subparsers is not None: parser.set_defaults(func=snake_case_ ) return parser def lowercase__ ( snake_case_ :List[Any] ): __UpperCAmelCase = torch.__version__ __UpperCAmelCase = torch.cuda.is_available() __UpperCAmelCase = is_xpu_available() __UpperCAmelCase = is_npu_available() __UpperCAmelCase = '''Not found''' # Get the default from the config file. if args.config_file is not None or os.path.isfile(snake_case_ ): __UpperCAmelCase = load_config_from_file(args.config_file ).to_dict() __UpperCAmelCase = { '''`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(snake_case_ ), '''PyTorch NPU available''': str(snake_case_ ), '''System RAM''': F'''{psutil.virtual_memory().total / 1_024 ** 3:.2f} GB''', } if pt_cuda_available: __UpperCAmelCase = 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 = ( '''\n'''.join([F'''\t- {prop}: {val}''' for prop, val in accelerate_config.items()] ) if isinstance(snake_case_ , snake_case_ ) else F'''\t{accelerate_config}''' ) print(snake_case_ ) __UpperCAmelCase = accelerate_config return info def lowercase__ ( ): __UpperCAmelCase = env_command_parser() __UpperCAmelCase = parser.parse_args() env_command(snake_case_ ) return 0 if __name__ == "__main__": raise SystemExit(main())
332
1
"""simple docstring""" from __future__ import annotations def lowercase__ ( snake_case_ :str , snake_case_ :list[str] | None = None , snake_case_ :dict[str, float] | None = None , snake_case_ :bool = False , ): __UpperCAmelCase = cipher_alphabet or [chr(snake_case_ ) for i in range(97 , 123 )] # If the argument is None or the user provided an empty dictionary if not frequencies_dict: # Frequencies of letters in the english language (how much they show up) __UpperCAmelCase = { '''a''': 0.08497, '''b''': 0.01492, '''c''': 0.02202, '''d''': 0.04253, '''e''': 0.11162, '''f''': 0.02228, '''g''': 0.02015, '''h''': 0.06094, '''i''': 0.07546, '''j''': 0.00153, '''k''': 0.01292, '''l''': 0.04025, '''m''': 0.02406, '''n''': 0.06749, '''o''': 0.07507, '''p''': 0.01929, '''q''': 0.00095, '''r''': 0.07587, '''s''': 0.06327, '''t''': 0.09356, '''u''': 0.02758, '''v''': 0.00978, '''w''': 0.02560, '''x''': 0.00150, '''y''': 0.01994, '''z''': 0.00077, } else: # Custom frequencies dictionary __UpperCAmelCase = frequencies_dict if not case_sensitive: __UpperCAmelCase = ciphertext.lower() # Chi squared statistic values __UpperCAmelCase = {} # cycle through all of the shifts for shift in range(len(snake_case_ ) ): __UpperCAmelCase = '''''' # decrypt the message with the shift for letter in ciphertext: try: # Try to index the letter in the alphabet __UpperCAmelCase = (alphabet_letters.index(letter.lower() ) - shift) % len( snake_case_ ) decrypted_with_shift += ( alphabet_letters[new_key].upper() if case_sensitive and letter.isupper() else alphabet_letters[new_key] ) except ValueError: # Append the character if it isn't in the alphabet decrypted_with_shift += letter __UpperCAmelCase = 0.0 # Loop through each letter in the decoded message with the shift for letter in decrypted_with_shift: if case_sensitive: __UpperCAmelCase = letter.lower() if letter in frequencies: # Get the amount of times the letter occurs in the message __UpperCAmelCase = decrypted_with_shift.lower().count(snake_case_ ) # Get the excepcted amount of times the letter should appear based # on letter frequencies __UpperCAmelCase = frequencies[letter] * occurrences # Complete the chi squared statistic formula __UpperCAmelCase = ((occurrences - expected) ** 2) / expected # Add the margin of error to the total chi squared statistic chi_squared_statistic += chi_letter_value else: if letter.lower() in frequencies: # Get the amount of times the letter occurs in the message __UpperCAmelCase = decrypted_with_shift.count(snake_case_ ) # Get the excepcted amount of times the letter should appear based # on letter frequencies __UpperCAmelCase = frequencies[letter] * occurrences # Complete the chi squared statistic formula __UpperCAmelCase = ((occurrences - expected) ** 2) / expected # Add the margin of error to the total chi squared statistic chi_squared_statistic += chi_letter_value # Add the data to the chi_squared_statistic_values dictionary __UpperCAmelCase = ( chi_squared_statistic, decrypted_with_shift, ) # Get the most likely cipher by finding the cipher with the smallest chi squared # statistic def chi_squared_statistic_values_sorting_key(snake_case_ :int ) -> tuple[float, str]: return chi_squared_statistic_values[key] __UpperCAmelCase = min( snake_case_ , key=snake_case_ , ) # Get all the data from the most likely cipher (key, decoded message) ( ( __UpperCAmelCase ) , ( __UpperCAmelCase ) , ) = chi_squared_statistic_values[most_likely_cipher] # Return the data on the most likely shift return ( most_likely_cipher, most_likely_cipher_chi_squared_value, decoded_most_likely_cipher, )
332
"""simple docstring""" import shutil import tempfile import unittest from transformers import SPIECE_UNDERLINE, BatchEncoding, MBartaaTokenizer, MBartaaTokenizerFast, is_torch_available from transformers.testing_utils import ( get_tests_dir, nested_simplify, require_sentencepiece, require_tokenizers, require_torch, slow, ) from ...test_tokenization_common import TokenizerTesterMixin _lowercase : Tuple = get_tests_dir('fixtures/test_sentencepiece.model') if is_torch_available(): from transformers.models.mbart.modeling_mbart import shift_tokens_right _lowercase : List[str] = 25_00_04 _lowercase : int = 25_00_20 @require_sentencepiece @require_tokenizers class _UpperCAmelCase ( _lowerCAmelCase , unittest.TestCase ): a__ : Union[str, Any] = MBartaaTokenizer a__ : List[str] = MBartaaTokenizerFast a__ : Any = True a__ : List[str] = True def a ( self : str ): super().setUp() # We have a SentencePiece fixture for testing __UpperCAmelCase = MBartaaTokenizer(_lowercase , src_lang='''en_XX''' , tgt_lang='''ro_RO''' , keep_accents=_lowercase ) tokenizer.save_pretrained(self.tmpdirname ) def a ( self : Dict ): __UpperCAmelCase = '''<s>''' __UpperCAmelCase = 0 self.assertEqual(self.get_tokenizer()._convert_token_to_id(_lowercase ) , _lowercase ) self.assertEqual(self.get_tokenizer()._convert_id_to_token(_lowercase ) , _lowercase ) def a ( self : Optional[Any] ): __UpperCAmelCase = list(self.get_tokenizer().get_vocab().keys() ) self.assertEqual(vocab_keys[0] , '''<s>''' ) self.assertEqual(vocab_keys[1] , '''<pad>''' ) self.assertEqual(vocab_keys[-1] , '''<mask>''' ) self.assertEqual(len(_lowercase ) , 10_54 ) def a ( self : Tuple ): self.assertEqual(self.get_tokenizer().vocab_size , 10_54 ) def a ( self : str ): __UpperCAmelCase = MBartaaTokenizer(_lowercase , src_lang='''en_XX''' , tgt_lang='''ro_RO''' , keep_accents=_lowercase ) __UpperCAmelCase = tokenizer.tokenize('''This is a test''' ) self.assertListEqual(_lowercase , ['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est'''] ) self.assertListEqual( tokenizer.convert_tokens_to_ids(_lowercase ) , [value + tokenizer.fairseq_offset for value in [2_85, 46, 10, 1_70, 3_82]] , ) __UpperCAmelCase = tokenizer.tokenize('''I was born in 92000, and this is falsé.''' ) self.assertListEqual( _lowercase , [SPIECE_UNDERLINE + '''I''', SPIECE_UNDERLINE + '''was''', SPIECE_UNDERLINE + '''b''', '''or''', '''n''', SPIECE_UNDERLINE + '''in''', SPIECE_UNDERLINE + '''''', '''9''', '''2''', '''0''', '''0''', '''0''', ''',''', SPIECE_UNDERLINE + '''and''', SPIECE_UNDERLINE + '''this''', SPIECE_UNDERLINE + '''is''', SPIECE_UNDERLINE + '''f''', '''al''', '''s''', '''é''', '''.'''] , ) __UpperCAmelCase = tokenizer.convert_tokens_to_ids(_lowercase ) self.assertListEqual( _lowercase , [ value + tokenizer.fairseq_offset for value in [8, 21, 84, 55, 24, 19, 7, 2, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 2, 4] ] , ) __UpperCAmelCase = tokenizer.convert_ids_to_tokens(_lowercase ) self.assertListEqual( _lowercase , [SPIECE_UNDERLINE + '''I''', SPIECE_UNDERLINE + '''was''', SPIECE_UNDERLINE + '''b''', '''or''', '''n''', SPIECE_UNDERLINE + '''in''', SPIECE_UNDERLINE + '''''', '''<unk>''', '''2''', '''0''', '''0''', '''0''', ''',''', SPIECE_UNDERLINE + '''and''', SPIECE_UNDERLINE + '''this''', SPIECE_UNDERLINE + '''is''', SPIECE_UNDERLINE + '''f''', '''al''', '''s''', '''<unk>''', '''.'''] , ) @slow def a ( self : str ): # fmt: off __UpperCAmelCase = {'''input_ids''': [[25_00_04, 1_10_62, 8_27_72, 7, 15, 8_27_72, 5_38, 5_15_29, 2_37, 1_71_98, 12_90, 2_06, 9, 21_51_75, 13_14, 1_36, 1_71_98, 12_90, 2_06, 9, 5_63_59, 42, 12_20_09, 9, 1_64_66, 16, 8_73_44, 45_37, 9, 47_17, 7_83_81, 6, 15_99_58, 7, 15, 2_44_80, 6_18, 4, 5_27, 2_26_93, 54_28, 4, 27_77, 2_44_80, 98_74, 4, 4_35_23, 5_94, 4, 8_03, 1_83_92, 3_31_89, 18, 4, 4_35_23, 2_44_47, 1_23_99, 1_00, 2_49_55, 8_36_58, 96_26, 14_40_57, 15, 8_39, 2_23_35, 16, 1_36, 2_49_55, 8_36_58, 8_34_79, 15, 3_91_02, 7_24, 16, 6_78, 6_45, 27_89, 13_28, 45_89, 42, 12_20_09, 11_57_74, 23, 8_05, 13_28, 4_68_76, 7, 1_36, 5_38_94, 19_40, 4_22_27, 4_11_59, 1_77_21, 8_23, 4_25, 4, 2_75_12, 9_87_22, 2_06, 1_36, 55_31, 49_70, 9_19, 1_73_36, 5, 2], [25_00_04, 2_00_80, 6_18, 83, 8_27_75, 47, 4_79, 9, 15_17, 73, 5_38_94, 3_33, 8_05_81, 11_01_17, 1_88_11, 52_56, 12_95, 51, 15_25_26, 2_97, 79_86, 3_90, 12_44_16, 5_38, 3_54_31, 2_14, 98, 1_50_44, 2_57_37, 1_36, 71_08, 4_37_01, 23, 7_56, 13_53_55, 7, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [25_00_04, 5_81, 6_37_73, 11_94_55, 6, 14_77_97, 8_82_03, 7, 6_45, 70, 21, 32_85, 1_02_69, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], '''attention_mask''': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]} # noqa: E501 # fmt: on self.tokenizer_integration_test_util( expected_encoding=_lowercase , model_name='''facebook/mbart-large-50''' , revision='''d3913889c59cd5c9e456b269c376325eabad57e2''' , ) def a ( self : 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 __UpperCAmelCase = (self.rust_tokenizer_class, '''hf-internal-testing/tiny-random-mbart50''', {}) for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})''' ): __UpperCAmelCase = self.rust_tokenizer_class.from_pretrained(_lowercase , **_lowercase ) __UpperCAmelCase = self.tokenizer_class.from_pretrained(_lowercase , **_lowercase ) __UpperCAmelCase = tempfile.mkdtemp() __UpperCAmelCase = tokenizer_r.save_pretrained(_lowercase ) __UpperCAmelCase = tokenizer_p.save_pretrained(_lowercase ) # Checks it save with the same files + the tokenizer.json file for the fast one self.assertTrue(any('''tokenizer.json''' in f for f in tokenizer_r_files ) ) __UpperCAmelCase = tuple(f for f in tokenizer_r_files if '''tokenizer.json''' not in f ) self.assertSequenceEqual(_lowercase , _lowercase ) # Checks everything loads correctly in the same way __UpperCAmelCase = tokenizer_r.from_pretrained(_lowercase ) __UpperCAmelCase = tokenizer_p.from_pretrained(_lowercase ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(_lowercase , _lowercase ) ) # self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key)) # self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id")) shutil.rmtree(_lowercase ) # Save tokenizer rust, legacy_format=True __UpperCAmelCase = tempfile.mkdtemp() __UpperCAmelCase = tokenizer_r.save_pretrained(_lowercase , legacy_format=_lowercase ) __UpperCAmelCase = tokenizer_p.save_pretrained(_lowercase ) # Checks it save with the same files self.assertSequenceEqual(_lowercase , _lowercase ) # Checks everything loads correctly in the same way __UpperCAmelCase = tokenizer_r.from_pretrained(_lowercase ) __UpperCAmelCase = tokenizer_p.from_pretrained(_lowercase ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(_lowercase , _lowercase ) ) shutil.rmtree(_lowercase ) # Save tokenizer rust, legacy_format=False __UpperCAmelCase = tempfile.mkdtemp() __UpperCAmelCase = tokenizer_r.save_pretrained(_lowercase , legacy_format=_lowercase ) __UpperCAmelCase = tokenizer_p.save_pretrained(_lowercase ) # Checks it saved the tokenizer.json file self.assertTrue(any('''tokenizer.json''' in f for f in tokenizer_r_files ) ) # Checks everything loads correctly in the same way __UpperCAmelCase = tokenizer_r.from_pretrained(_lowercase ) __UpperCAmelCase = tokenizer_p.from_pretrained(_lowercase ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(_lowercase , _lowercase ) ) shutil.rmtree(_lowercase ) @require_torch @require_sentencepiece @require_tokenizers class _UpperCAmelCase ( unittest.TestCase ): a__ : str = "facebook/mbart-large-50-one-to-many-mmt" a__ : Union[str, Any] = [ " UN Chief Says There Is No Military Solution in Syria", " Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.", ] a__ : Any = [ "Şeful ONU declară că nu există o soluţie militară în Siria", "Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei" " pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor" " face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.", ] a__ : Any = [EN_CODE, 8_274, 127_873, 25_916, 7, 8_622, 2_071, 438, 67_485, 53, 187_895, 23, 51_712, 2] @classmethod def a ( cls : Tuple ): __UpperCAmelCase = MBartaaTokenizer.from_pretrained( cls.checkpoint_name , src_lang='''en_XX''' , tgt_lang='''ro_RO''' ) __UpperCAmelCase = 1 return cls def a ( self : Union[str, Any] ): self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ar_AR'''] , 25_00_01 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''en_EN'''] , 25_00_04 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ro_RO'''] , 25_00_20 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''mr_IN'''] , 25_00_38 ) def a ( self : Union[str, Any] ): __UpperCAmelCase = self.tokenizer.batch_encode_plus(self.src_text ).input_ids[0] self.assertListEqual(self.expected_src_tokens , _lowercase ) def a ( self : Optional[Any] ): self.assertIn(_lowercase , self.tokenizer.all_special_ids ) __UpperCAmelCase = [RO_CODE, 8_84, 90_19, 96, 9, 9_16, 8_67_92, 36, 1_87_43, 1_55_96, 5, 2] __UpperCAmelCase = self.tokenizer.decode(_lowercase , skip_special_tokens=_lowercase ) __UpperCAmelCase = self.tokenizer.decode(generated_ids[1:] , skip_special_tokens=_lowercase ) self.assertEqual(_lowercase , _lowercase ) self.assertNotIn(self.tokenizer.eos_token , _lowercase ) def a ( self : Optional[Any] ): __UpperCAmelCase = ['''this is gunna be a long sentence ''' * 20] assert isinstance(src_text[0] , _lowercase ) __UpperCAmelCase = 10 __UpperCAmelCase = self.tokenizer(_lowercase , max_length=_lowercase , truncation=_lowercase ).input_ids[0] self.assertEqual(ids[0] , _lowercase ) self.assertEqual(ids[-1] , 2 ) self.assertEqual(len(_lowercase ) , _lowercase ) def a ( self : Optional[int] ): self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['''<mask>''', '''ar_AR'''] ) , [25_00_53, 25_00_01] ) def a ( self : Union[str, Any] ): __UpperCAmelCase = tempfile.mkdtemp() __UpperCAmelCase = self.tokenizer.fairseq_tokens_to_ids self.tokenizer.save_pretrained(_lowercase ) __UpperCAmelCase = MBartaaTokenizer.from_pretrained(_lowercase ) self.assertDictEqual(new_tok.fairseq_tokens_to_ids , _lowercase ) @require_torch def a ( self : Dict ): __UpperCAmelCase = self.tokenizer(self.src_text , text_target=self.tgt_text , padding=_lowercase , return_tensors='''pt''' ) __UpperCAmelCase = shift_tokens_right(batch['''labels'''] , self.tokenizer.pad_token_id ) # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4 assert batch.input_ids[1][0] == EN_CODE assert batch.input_ids[1][-1] == 2 assert batch.labels[1][0] == RO_CODE assert batch.labels[1][-1] == 2 assert batch.decoder_input_ids[1][:2].tolist() == [2, RO_CODE] @require_torch def a ( self : Union[str, Any] ): __UpperCAmelCase = self.tokenizer( self.src_text , text_target=self.tgt_text , padding=_lowercase , truncation=_lowercase , max_length=len(self.expected_src_tokens ) , return_tensors='''pt''' , ) __UpperCAmelCase = shift_tokens_right(batch['''labels'''] , self.tokenizer.pad_token_id ) self.assertIsInstance(_lowercase , _lowercase ) self.assertEqual((2, 14) , batch.input_ids.shape ) self.assertEqual((2, 14) , batch.attention_mask.shape ) __UpperCAmelCase = batch.input_ids.tolist()[0] self.assertListEqual(self.expected_src_tokens , _lowercase ) self.assertEqual(2 , batch.decoder_input_ids[0, 0] ) # decoder_start_token_id # Test that special tokens are reset self.assertEqual(self.tokenizer.prefix_tokens , [EN_CODE] ) self.assertEqual(self.tokenizer.suffix_tokens , [self.tokenizer.eos_token_id] ) def a ( self : Union[str, Any] ): __UpperCAmelCase = self.tokenizer(self.src_text , padding=_lowercase , truncation=_lowercase , max_length=3 , return_tensors='''pt''' ) __UpperCAmelCase = self.tokenizer( text_target=self.tgt_text , padding=_lowercase , truncation=_lowercase , max_length=10 , return_tensors='''pt''' ) __UpperCAmelCase = targets['''input_ids'''] __UpperCAmelCase = shift_tokens_right(_lowercase , self.tokenizer.pad_token_id ) self.assertEqual(batch.input_ids.shape[1] , 3 ) self.assertEqual(batch.decoder_input_ids.shape[1] , 10 ) @require_torch def a ( self : Dict ): __UpperCAmelCase = self.tokenizer._build_translation_inputs( '''A test''' , return_tensors='''pt''' , src_lang='''en_XX''' , tgt_lang='''ar_AR''' ) self.assertEqual( nested_simplify(_lowercase ) , { # en_XX, A, test, EOS '''input_ids''': [[25_00_04, 62, 30_34, 2]], '''attention_mask''': [[1, 1, 1, 1]], # ar_AR '''forced_bos_token_id''': 25_00_01, } , )
332
1
"""simple docstring""" import json import os import re import shutil import tempfile import unittest from typing import Tuple from transformers import AddedToken, BatchEncoding, PerceiverTokenizer from transformers.utils import cached_property, is_tf_available, is_torch_available from ...test_tokenization_common import TokenizerTesterMixin if is_torch_available(): _lowercase : List[str] = 'pt' elif is_tf_available(): _lowercase : str = 'tf' else: _lowercase : Optional[Any] = 'jax' class _UpperCAmelCase ( _lowerCAmelCase , unittest.TestCase ): a__ : List[Any] = PerceiverTokenizer a__ : str = False def a ( self : Optional[int] ): super().setUp() __UpperCAmelCase = PerceiverTokenizer() tokenizer.save_pretrained(self.tmpdirname ) @cached_property def a ( self : Optional[Any] ): return PerceiverTokenizer.from_pretrained('''deepmind/language-perceiver''' ) def a ( self : Tuple , **_lowercase : Optional[Any] ): return self.tokenizer_class.from_pretrained(self.tmpdirname , **_lowercase ) def a ( self : List[str] , _lowercase : Tuple , _lowercase : str=False , _lowercase : Tuple=20 , _lowercase : Any=5 ): # XXX The default common tokenizer tests assume that every ID is decodable on its own. # This assumption is invalid for Perceiver because single bytes might not be # valid utf-8 (byte 128 for instance). # Here we're overriding the smallest possible method to provide # a clean sequence without making the same assumption. __UpperCAmelCase = [] for i in range(len(_lowercase ) ): try: __UpperCAmelCase = tokenizer.decode([i] , clean_up_tokenization_spaces=_lowercase ) except UnicodeDecodeError: pass toks.append((i, tok) ) __UpperCAmelCase = list(filter(lambda _lowercase : re.match(r'''^[ a-zA-Z]+$''' , t[1] ) , _lowercase ) ) __UpperCAmelCase = list(filter(lambda _lowercase : [t[0]] == tokenizer.encode(t[1] , add_special_tokens=_lowercase ) , _lowercase ) ) if max_length is not None and len(_lowercase ) > max_length: __UpperCAmelCase = toks[:max_length] if min_length is not None and len(_lowercase ) < min_length and len(_lowercase ) > 0: while len(_lowercase ) < min_length: __UpperCAmelCase = toks + toks # toks_str = [t[1] for t in toks] __UpperCAmelCase = [t[0] for t in toks] # Ensure consistency __UpperCAmelCase = tokenizer.decode(_lowercase , clean_up_tokenization_spaces=_lowercase ) if " " not in output_txt and len(_lowercase ) > 1: __UpperCAmelCase = ( tokenizer.decode([toks_ids[0]] , clean_up_tokenization_spaces=_lowercase ) + ''' ''' + tokenizer.decode(toks_ids[1:] , clean_up_tokenization_spaces=_lowercase ) ) if with_prefix_space: __UpperCAmelCase = ''' ''' + output_txt __UpperCAmelCase = tokenizer.encode(_lowercase , add_special_tokens=_lowercase ) return output_txt, output_ids def a ( self : str ): __UpperCAmelCase = self.perceiver_tokenizer __UpperCAmelCase = '''Unicode €.''' __UpperCAmelCase = tokenizer(_lowercase ) __UpperCAmelCase = [4, 91, 1_16, 1_11, 1_05, 1_17, 1_06, 1_07, 38, 2_32, 1_36, 1_78, 52, 5] self.assertEqual(encoded['''input_ids'''] , _lowercase ) # decoding __UpperCAmelCase = tokenizer.decode(_lowercase ) self.assertEqual(_lowercase , '''[CLS]Unicode €.[SEP]''' ) __UpperCAmelCase = tokenizer('''e è é ê ë''' ) __UpperCAmelCase = [4, 1_07, 38, 2_01, 1_74, 38, 2_01, 1_75, 38, 2_01, 1_76, 38, 2_01, 1_77, 5] self.assertEqual(encoded['''input_ids'''] , _lowercase ) # decoding __UpperCAmelCase = tokenizer.decode(_lowercase ) self.assertEqual(_lowercase , '''[CLS]e è é ê ë[SEP]''' ) # encode/decode, but with `encode` instead of `__call__` self.assertEqual(tokenizer.decode(tokenizer.encode('''e è é ê ë''' ) ) , '''[CLS]e è é ê ë[SEP]''' ) def a ( self : List[Any] ): __UpperCAmelCase = self.perceiver_tokenizer __UpperCAmelCase = ['''A long paragraph for summarization.''', '''Another paragraph for summarization.'''] # fmt: off __UpperCAmelCase = [4, 71, 38, 1_14, 1_17, 1_16, 1_09, 38, 1_18, 1_03, 1_20, 1_03, 1_09, 1_20, 1_03, 1_18, 1_10, 38, 1_08, 1_17, 1_20, 38, 1_21, 1_23, 1_15, 1_15, 1_03, 1_20, 1_11, 1_28, 1_03, 1_22, 1_11, 1_17, 1_16, 52, 5, 0] # fmt: on __UpperCAmelCase = tokenizer(_lowercase , padding=_lowercase , return_tensors=_lowercase ) self.assertIsInstance(_lowercase , _lowercase ) if FRAMEWORK != "jax": __UpperCAmelCase = list(batch.input_ids.numpy()[0] ) else: __UpperCAmelCase = list(batch.input_ids.tolist()[0] ) self.assertListEqual(_lowercase , _lowercase ) self.assertEqual((2, 38) , batch.input_ids.shape ) self.assertEqual((2, 38) , batch.attention_mask.shape ) def a ( self : str ): __UpperCAmelCase = self.perceiver_tokenizer __UpperCAmelCase = ['''A long paragraph for summarization.''', '''Another paragraph for summarization.'''] __UpperCAmelCase = tokenizer(_lowercase , padding=_lowercase , return_tensors=_lowercase ) # check if input_ids are returned and no decoder_input_ids self.assertIn('''input_ids''' , _lowercase ) self.assertIn('''attention_mask''' , _lowercase ) self.assertNotIn('''decoder_input_ids''' , _lowercase ) self.assertNotIn('''decoder_attention_mask''' , _lowercase ) def a ( self : Optional[int] ): __UpperCAmelCase = self.perceiver_tokenizer __UpperCAmelCase = [ '''Summary of the text.''', '''Another summary.''', ] __UpperCAmelCase = tokenizer( text_target=_lowercase , max_length=32 , padding='''max_length''' , truncation=_lowercase , return_tensors=_lowercase ) self.assertEqual(32 , targets['''input_ids'''].shape[1] ) def a ( self : str ): # safety check on max_len default value so we are sure the test works __UpperCAmelCase = self.get_tokenizers() for tokenizer in tokenizers: with self.subTest(F'''{tokenizer.__class__.__name__}''' ): self.assertNotEqual(tokenizer.model_max_length , 42 ) # Now let's start the test __UpperCAmelCase = self.get_tokenizers() for tokenizer in tokenizers: with self.subTest(F'''{tokenizer.__class__.__name__}''' ): # Isolate this from the other tests because we save additional tokens/etc __UpperCAmelCase = tempfile.mkdtemp() __UpperCAmelCase = ''' He is very happy, UNwant\u00E9d,running''' __UpperCAmelCase = tokenizer.encode(_lowercase , add_special_tokens=_lowercase ) tokenizer.save_pretrained(_lowercase ) __UpperCAmelCase = tokenizer.__class__.from_pretrained(_lowercase ) __UpperCAmelCase = after_tokenizer.encode(_lowercase , add_special_tokens=_lowercase ) self.assertListEqual(_lowercase , _lowercase ) shutil.rmtree(_lowercase ) __UpperCAmelCase = self.get_tokenizers(model_max_length=42 ) for tokenizer in tokenizers: with self.subTest(F'''{tokenizer.__class__.__name__}''' ): # Isolate this from the other tests because we save additional tokens/etc __UpperCAmelCase = tempfile.mkdtemp() __UpperCAmelCase = ''' He is very happy, UNwant\u00E9d,running''' tokenizer.add_tokens(['''bim''', '''bambam'''] ) __UpperCAmelCase = tokenizer.additional_special_tokens additional_special_tokens.append('''new_additional_special_token''' ) tokenizer.add_special_tokens({'''additional_special_tokens''': additional_special_tokens} ) __UpperCAmelCase = tokenizer.encode(_lowercase , add_special_tokens=_lowercase ) tokenizer.save_pretrained(_lowercase ) __UpperCAmelCase = tokenizer.__class__.from_pretrained(_lowercase ) __UpperCAmelCase = after_tokenizer.encode(_lowercase , add_special_tokens=_lowercase ) self.assertListEqual(_lowercase , _lowercase ) self.assertIn('''new_additional_special_token''' , after_tokenizer.additional_special_tokens ) self.assertEqual(after_tokenizer.model_max_length , 42 ) __UpperCAmelCase = tokenizer.__class__.from_pretrained(_lowercase , model_max_length=43 ) self.assertEqual(tokenizer.model_max_length , 43 ) shutil.rmtree(_lowercase ) def a ( self : int ): __UpperCAmelCase = [] if self.test_slow_tokenizer: tokenizer_list.append((self.tokenizer_class, self.get_tokenizer()) ) if self.test_rust_tokenizer: tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer()) ) for tokenizer_class, tokenizer_utils in tokenizer_list: with tempfile.TemporaryDirectory() as tmp_dir: tokenizer_utils.save_pretrained(_lowercase ) with open(os.path.join(_lowercase , '''special_tokens_map.json''' ) , encoding='''utf-8''' ) as json_file: __UpperCAmelCase = json.load(_lowercase ) with open(os.path.join(_lowercase , '''tokenizer_config.json''' ) , encoding='''utf-8''' ) as json_file: __UpperCAmelCase = json.load(_lowercase ) __UpperCAmelCase = [F'''<extra_id_{i}>''' for i in range(1_25 )] __UpperCAmelCase = added_tokens_extra_ids + [ '''an_additional_special_token''' ] __UpperCAmelCase = added_tokens_extra_ids + [ '''an_additional_special_token''' ] with open(os.path.join(_lowercase , '''special_tokens_map.json''' ) , '''w''' , encoding='''utf-8''' ) as outfile: json.dump(_lowercase , _lowercase ) with open(os.path.join(_lowercase , '''tokenizer_config.json''' ) , '''w''' , encoding='''utf-8''' ) as outfile: json.dump(_lowercase , _lowercase ) # the following checks allow us to verify that our test works as expected, i.e. that the tokenizer takes # into account the new value of additional_special_tokens given in the "tokenizer_config.json" and # "special_tokens_map.json" files __UpperCAmelCase = tokenizer_class.from_pretrained( _lowercase , ) self.assertIn( '''an_additional_special_token''' , tokenizer_without_change_in_init.additional_special_tokens ) self.assertEqual( ['''an_additional_special_token'''] , tokenizer_without_change_in_init.convert_ids_to_tokens( tokenizer_without_change_in_init.convert_tokens_to_ids(['''an_additional_special_token'''] ) ) , ) # Now we test that we can change the value of additional_special_tokens in the from_pretrained __UpperCAmelCase = added_tokens_extra_ids + [AddedToken('''a_new_additional_special_token''' , lstrip=_lowercase )] __UpperCAmelCase = tokenizer_class.from_pretrained( _lowercase , additional_special_tokens=_lowercase , ) self.assertIn('''a_new_additional_special_token''' , tokenizer.additional_special_tokens ) self.assertEqual( ['''a_new_additional_special_token'''] , tokenizer.convert_ids_to_tokens( tokenizer.convert_tokens_to_ids(['''a_new_additional_special_token'''] ) ) , ) def a ( self : List[str] ): __UpperCAmelCase = self.perceiver_tokenizer self.assertEqual(tokenizer.decode([1_78] ) , '''�''' ) def a ( self : Any ): pass def a ( self : Tuple ): pass def a ( self : Dict ): pass def a ( self : Dict ): pass def a ( self : Tuple ): # The default common tokenizer tests uses invalid tokens for Perceiver that can only accept one-character # strings and special added tokens as tokens __UpperCAmelCase = self.get_tokenizers(fast=_lowercase , do_lower_case=_lowercase ) for tokenizer in tokenizers: with self.subTest(F'''{tokenizer.__class__.__name__}''' ): __UpperCAmelCase = ['''[CLS]''', '''t''', '''h''', '''i''', '''s''', ''' ''', '''i''', '''s''', ''' ''', '''a''', ''' ''', '''t''', '''e''', '''s''', '''t''', '''[SEP]'''] __UpperCAmelCase = tokenizer.convert_tokens_to_string(_lowercase ) self.assertIsInstance(_lowercase , _lowercase )
332
"""simple docstring""" import unittest import torch from torch import nn from accelerate.test_utils import require_cuda from accelerate.utils.memory import find_executable_batch_size, release_memory def lowercase__ ( ): raise RuntimeError('''CUDA out of memory.''' ) class _UpperCAmelCase ( nn.Module ): def __init__( self : Optional[Any] ): super().__init__() __UpperCAmelCase = nn.Linear(3 , 4 ) __UpperCAmelCase = nn.BatchNormad(4 ) __UpperCAmelCase = nn.Linear(4 , 5 ) def a ( self : Optional[int] , _lowercase : Optional[Any] ): return self.lineara(self.batchnorm(self.lineara(_lowercase ) ) ) class _UpperCAmelCase ( unittest.TestCase ): def a ( self : List[str] ): __UpperCAmelCase = [] @find_executable_batch_size(starting_batch_size=1_28 ) def mock_training_loop_function(_lowercase : Optional[int] ): nonlocal batch_sizes batch_sizes.append(_lowercase ) if batch_size != 8: raise_fake_out_of_memory() mock_training_loop_function() self.assertListEqual(_lowercase , [1_28, 64, 32, 16, 8] ) def a ( self : Optional[int] ): __UpperCAmelCase = [] @find_executable_batch_size(starting_batch_size=1_28 ) def mock_training_loop_function(_lowercase : str , _lowercase : List[str] ): nonlocal batch_sizes batch_sizes.append(_lowercase ) if batch_size != 8: raise_fake_out_of_memory() return batch_size, arga __UpperCAmelCase , __UpperCAmelCase = mock_training_loop_function('''hello''' ) self.assertListEqual(_lowercase , [1_28, 64, 32, 16, 8] ) self.assertListEqual([bs, arga] , [8, '''hello'''] ) def a ( self : Tuple ): @find_executable_batch_size(starting_batch_size=0 ) def mock_training_loop_function(_lowercase : Optional[int] ): pass with self.assertRaises(_lowercase ) as cm: mock_training_loop_function() self.assertIn('''No executable batch size found, reached zero.''' , cm.exception.args[0] ) def a ( self : List[Any] ): @find_executable_batch_size(starting_batch_size=16 ) def mock_training_loop_function(_lowercase : List[Any] ): if batch_size > 0: raise_fake_out_of_memory() pass with self.assertRaises(_lowercase ) as cm: mock_training_loop_function() self.assertIn('''No executable batch size found, reached zero.''' , cm.exception.args[0] ) def a ( self : Union[str, Any] ): @find_executable_batch_size(starting_batch_size=1_28 ) def mock_training_loop_function(_lowercase : Optional[Any] , _lowercase : List[str] , _lowercase : str ): if batch_size != 8: raise raise_fake_out_of_memory() with self.assertRaises(_lowercase ) as cm: mock_training_loop_function(1_28 , '''hello''' , '''world''' ) self.assertIn('''Batch size was passed into `f`''' , cm.exception.args[0] ) self.assertIn('''`f(arg1=\'hello\', arg2=\'world\')''' , cm.exception.args[0] ) def a ( self : Dict ): @find_executable_batch_size(starting_batch_size=16 ) def mock_training_loop_function(_lowercase : int ): raise ValueError('''Oops, we had an error!''' ) with self.assertRaises(_lowercase ) as cm: mock_training_loop_function() self.assertIn('''Oops, we had an error!''' , cm.exception.args[0] ) @require_cuda def a ( self : str ): __UpperCAmelCase = torch.cuda.memory_allocated() __UpperCAmelCase = ModelForTest() model.cuda() self.assertGreater(torch.cuda.memory_allocated() , _lowercase ) __UpperCAmelCase = release_memory(_lowercase ) self.assertEqual(torch.cuda.memory_allocated() , _lowercase )
332
1
"""simple docstring""" from __future__ import annotations from collections.abc import Callable from typing import Generic, TypeVar _lowercase : str = TypeVar('T') _lowercase : Tuple = TypeVar('U') class _UpperCAmelCase ( Generic[T, U] ): def __init__( self : Any , _lowercase : T | None , _lowercase : U | None ): __UpperCAmelCase = key __UpperCAmelCase = val __UpperCAmelCase = None __UpperCAmelCase = None def __repr__( self : Optional[Any] ): return ( F'''Node: key: {self.key}, val: {self.val}, ''' F'''has next: {bool(self.next )}, has prev: {bool(self.prev )}''' ) class _UpperCAmelCase ( Generic[T, U] ): def __init__( self : int ): __UpperCAmelCase = DoubleLinkedListNode(_lowercase , _lowercase ) __UpperCAmelCase = DoubleLinkedListNode(_lowercase , _lowercase ) __UpperCAmelCase , __UpperCAmelCase = self.rear, self.head def __repr__( self : str ): __UpperCAmelCase = ['''DoubleLinkedList'''] __UpperCAmelCase = self.head while node.next is not None: rep.append(str(_lowercase ) ) __UpperCAmelCase = node.next rep.append(str(self.rear ) ) return ",\n ".join(_lowercase ) def a ( self : Dict , _lowercase : DoubleLinkedListNode[T, U] ): __UpperCAmelCase = self.rear.prev # All nodes other than self.head are guaranteed to have non-None previous assert previous is not None __UpperCAmelCase = node __UpperCAmelCase = previous __UpperCAmelCase = node __UpperCAmelCase = self.rear def a ( self : int , _lowercase : DoubleLinkedListNode[T, U] ): if node.prev is None or node.next is None: return None __UpperCAmelCase = node.next __UpperCAmelCase = node.prev __UpperCAmelCase = None __UpperCAmelCase = None return node class _UpperCAmelCase ( Generic[T, U] ): a__ : dict[Callable[[T], U], LRUCache[T, U]] = {} def __init__( self : Union[str, Any] , _lowercase : int ): __UpperCAmelCase = DoubleLinkedList() __UpperCAmelCase = capacity __UpperCAmelCase = 0 __UpperCAmelCase = 0 __UpperCAmelCase = 0 __UpperCAmelCase = {} def __repr__( self : List[Any] ): return ( F'''CacheInfo(hits={self.hits}, misses={self.miss}, ''' F'''capacity={self.capacity}, current size={self.num_keys})''' ) def __contains__( self : List[Any] , _lowercase : T ): return key in self.cache def a ( self : int , _lowercase : T ): # Note: pythonic interface would throw KeyError rather than return None if key in self.cache: self.hits += 1 __UpperCAmelCase = self.cache[key] __UpperCAmelCase = self.list.remove(self.cache[key] ) assert node == value_node # node is guaranteed not None because it is in self.cache assert node is not None self.list.add(_lowercase ) return node.val self.miss += 1 return None def a ( self : Tuple , _lowercase : T , _lowercase : U ): if key not in self.cache: if self.num_keys >= self.capacity: # delete first node (oldest) when over capacity __UpperCAmelCase = self.list.head.next # guaranteed to have a non-None first node when num_keys > 0 # explain to type checker via assertions assert first_node is not None assert first_node.key is not None assert ( self.list.remove(_lowercase ) is not None ) # node guaranteed to be in list assert node.key is not None del self.cache[first_node.key] self.num_keys -= 1 __UpperCAmelCase = DoubleLinkedListNode(_lowercase , _lowercase ) self.list.add(self.cache[key] ) self.num_keys += 1 else: # bump node to the end of the list, update value __UpperCAmelCase = self.list.remove(self.cache[key] ) assert node is not None # node guaranteed to be in list __UpperCAmelCase = value self.list.add(_lowercase ) @classmethod def a ( cls : Dict , _lowercase : int = 1_28 ): def cache_decorator_inner(_lowercase : Callable[[T], U] ) -> Callable[..., U]: def cache_decorator_wrapper(*_lowercase : T ) -> U: if func not in cls.decorator_function_to_instance_map: __UpperCAmelCase = LRUCache(_lowercase ) __UpperCAmelCase = cls.decorator_function_to_instance_map[func].get(args[0] ) if result is None: __UpperCAmelCase = func(*_lowercase ) cls.decorator_function_to_instance_map[func].put(args[0] , _lowercase ) return result def cache_info() -> LRUCache[T, U]: return cls.decorator_function_to_instance_map[func] setattr(_lowercase , '''cache_info''' , _lowercase ) # noqa: B010 return cache_decorator_wrapper return cache_decorator_inner if __name__ == "__main__": import doctest doctest.testmod()
332
"""simple docstring""" import argparse import copy def lowercase__ ( snake_case_ :Tuple ): __UpperCAmelCase = {} with open(snake_case_ ) as f: for line in f: if line.split()[0] not in dict_of_neighbours: __UpperCAmelCase = [] _list.append([line.split()[1], line.split()[2]] ) __UpperCAmelCase = _list else: dict_of_neighbours[line.split()[0]].append( [line.split()[1], line.split()[2]] ) if line.split()[1] not in dict_of_neighbours: __UpperCAmelCase = [] _list.append([line.split()[0], line.split()[2]] ) __UpperCAmelCase = _list else: dict_of_neighbours[line.split()[1]].append( [line.split()[0], line.split()[2]] ) return dict_of_neighbours def lowercase__ ( snake_case_ :Dict , snake_case_ :Optional[Any] ): with open(snake_case_ ) as f: __UpperCAmelCase = f.read(1 ) __UpperCAmelCase = start_node __UpperCAmelCase = [] __UpperCAmelCase = start_node __UpperCAmelCase = 0 while visiting not in first_solution: __UpperCAmelCase = 10_000 for k in dict_of_neighbours[visiting]: if int(k[1] ) < int(snake_case_ ) and k[0] not in first_solution: __UpperCAmelCase = k[1] __UpperCAmelCase = k[0] first_solution.append(snake_case_ ) __UpperCAmelCase = distance_of_first_solution + int(snake_case_ ) __UpperCAmelCase = best_node first_solution.append(snake_case_ ) __UpperCAmelCase = 0 for k in dict_of_neighbours[first_solution[-2]]: if k[0] == start_node: break position += 1 __UpperCAmelCase = ( distance_of_first_solution + int(dict_of_neighbours[first_solution[-2]][position][1] ) - 10_000 ) return first_solution, distance_of_first_solution def lowercase__ ( snake_case_ :int , snake_case_ :Tuple ): __UpperCAmelCase = [] for n in solution[1:-1]: __UpperCAmelCase = solution.index(snake_case_ ) for kn in solution[1:-1]: __UpperCAmelCase = solution.index(snake_case_ ) if n == kn: continue __UpperCAmelCase = copy.deepcopy(snake_case_ ) __UpperCAmelCase = kn __UpperCAmelCase = n __UpperCAmelCase = 0 for k in _tmp[:-1]: __UpperCAmelCase = _tmp[_tmp.index(snake_case_ ) + 1] for i in dict_of_neighbours[k]: if i[0] == next_node: __UpperCAmelCase = distance + int(i[1] ) _tmp.append(snake_case_ ) if _tmp not in neighborhood_of_solution: neighborhood_of_solution.append(_tmp ) __UpperCAmelCase = len(neighborhood_of_solution[0] ) - 1 neighborhood_of_solution.sort(key=lambda snake_case_ : x[index_of_last_item_in_the_list] ) return neighborhood_of_solution def lowercase__ ( snake_case_ :str , snake_case_ :Union[str, Any] , snake_case_ :Optional[int] , snake_case_ :Dict , snake_case_ :int ): __UpperCAmelCase = 1 __UpperCAmelCase = first_solution __UpperCAmelCase = [] __UpperCAmelCase = distance_of_first_solution __UpperCAmelCase = solution while count <= iters: __UpperCAmelCase = find_neighborhood(snake_case_ , snake_case_ ) __UpperCAmelCase = 0 __UpperCAmelCase = neighborhood[index_of_best_solution] __UpperCAmelCase = len(snake_case_ ) - 1 __UpperCAmelCase = False while not found: __UpperCAmelCase = 0 while i < len(snake_case_ ): if best_solution[i] != solution[i]: __UpperCAmelCase = best_solution[i] __UpperCAmelCase = solution[i] break __UpperCAmelCase = i + 1 if [first_exchange_node, second_exchange_node] not in tabu_list and [ second_exchange_node, first_exchange_node, ] not in tabu_list: tabu_list.append([first_exchange_node, second_exchange_node] ) __UpperCAmelCase = True __UpperCAmelCase = best_solution[:-1] __UpperCAmelCase = neighborhood[index_of_best_solution][best_cost_index] if cost < best_cost: __UpperCAmelCase = cost __UpperCAmelCase = solution else: __UpperCAmelCase = index_of_best_solution + 1 __UpperCAmelCase = neighborhood[index_of_best_solution] if len(snake_case_ ) >= size: tabu_list.pop(0 ) __UpperCAmelCase = count + 1 return best_solution_ever, best_cost def lowercase__ ( snake_case_ :str=None ): __UpperCAmelCase = generate_neighbours(args.File ) __UpperCAmelCase , __UpperCAmelCase = generate_first_solution( args.File , snake_case_ ) __UpperCAmelCase , __UpperCAmelCase = tabu_search( snake_case_ , snake_case_ , snake_case_ , args.Iterations , args.Size , ) print(F'''Best solution: {best_sol}, with total distance: {best_cost}.''' ) if __name__ == "__main__": _lowercase : List[str] = argparse.ArgumentParser(description='Tabu Search') parser.add_argument( '-f', '--File', type=str, help='Path to the file containing the data', required=True, ) parser.add_argument( '-i', '--Iterations', type=int, help='How many iterations the algorithm should perform', required=True, ) parser.add_argument( '-s', '--Size', type=int, help='Size of the tabu list', required=True ) # Pass the arguments to main method main(parser.parse_args())
332
1
"""simple docstring""" 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 _UpperCAmelCase ( unittest.TestCase ): def __init__( self : str , _lowercase : Union[str, Any] , _lowercase : bool = True , _lowercase : Dict[str, int] = None , _lowercase : int = 32 , _lowercase : bool = True , _lowercase : Union[int, float] = 1 / 2_55 , _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 : Optional[int]=7 , _lowercase : Optional[int]=30 , _lowercase : List[str]=4_00 , _lowercase : Optional[int]=3 , ): __UpperCAmelCase = parent __UpperCAmelCase = do_resize __UpperCAmelCase = size if size is not None else {'''shortest_edge''': 2_88} __UpperCAmelCase = size_divisor __UpperCAmelCase = do_rescale __UpperCAmelCase = rescale_factor __UpperCAmelCase = do_normalize __UpperCAmelCase = do_center_crop __UpperCAmelCase = image_mean __UpperCAmelCase = image_std __UpperCAmelCase = do_pad __UpperCAmelCase = batch_size __UpperCAmelCase = num_channels __UpperCAmelCase = min_resolution __UpperCAmelCase = max_resolution def a ( self : str ): 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 a ( self : List[str] , _lowercase : List[str] , _lowercase : str=False ): if not batched: __UpperCAmelCase = self.size['''shortest_edge'''] __UpperCAmelCase = image_inputs[0] if isinstance(_lowercase , Image.Image ): __UpperCAmelCase , __UpperCAmelCase = image.size else: __UpperCAmelCase , __UpperCAmelCase = image.shape[1], image.shape[2] __UpperCAmelCase = size / min(_lowercase , _lowercase ) if h < w: __UpperCAmelCase , __UpperCAmelCase = size, scale * w else: __UpperCAmelCase , __UpperCAmelCase = scale * h, size __UpperCAmelCase = int((13_33 / 8_00) * size ) if max(_lowercase , _lowercase ) > max_size: __UpperCAmelCase = max_size / max(_lowercase , _lowercase ) __UpperCAmelCase = newh * scale __UpperCAmelCase = neww * scale __UpperCAmelCase , __UpperCAmelCase = int(newh + 0.5 ), int(neww + 0.5 ) __UpperCAmelCase , __UpperCAmelCase = ( newh // self.size_divisor * self.size_divisor, neww // self.size_divisor * self.size_divisor, ) else: __UpperCAmelCase = [] for image in image_inputs: __UpperCAmelCase , __UpperCAmelCase = self.get_expected_values([image] ) expected_values.append((expected_height, expected_width) ) __UpperCAmelCase = max(_lowercase , key=lambda _lowercase : item[0] )[0] __UpperCAmelCase = max(_lowercase , key=lambda _lowercase : item[1] )[1] return expected_height, expected_width @require_torch @require_vision class _UpperCAmelCase ( _lowerCAmelCase , unittest.TestCase ): a__ : Optional[int] = BridgeTowerImageProcessor if is_vision_available() else None def a ( self : int ): __UpperCAmelCase = BridgeTowerImageProcessingTester(self ) @property def a ( self : Any ): return self.image_processor_tester.prepare_image_processor_dict() def a ( self : int ): __UpperCAmelCase = 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 a ( self : Dict ): pass def a ( self : Union[str, Any] ): # Initialize image processor __UpperCAmelCase = self.image_processing_class(**self.image_processor_dict ) # create random PIL images __UpperCAmelCase = prepare_image_inputs(self.image_processor_tester , equal_resolution=_lowercase ) for image in image_inputs: self.assertIsInstance(_lowercase , Image.Image ) # Test not batched input __UpperCAmelCase = image_processing(image_inputs[0] , return_tensors='''pt''' ).pixel_values __UpperCAmelCase , __UpperCAmelCase = self.image_processor_tester.get_expected_values(_lowercase ) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched __UpperCAmelCase = image_processing(_lowercase , return_tensors='''pt''' ).pixel_values __UpperCAmelCase , __UpperCAmelCase = 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 a ( self : int ): # Initialize image processor __UpperCAmelCase = self.image_processing_class(**self.image_processor_dict ) # create random numpy tensors __UpperCAmelCase = 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 __UpperCAmelCase = image_processing(image_inputs[0] , return_tensors='''pt''' ).pixel_values __UpperCAmelCase , __UpperCAmelCase = 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 __UpperCAmelCase = image_processing(_lowercase , return_tensors='''pt''' ).pixel_values __UpperCAmelCase , __UpperCAmelCase = 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 a ( self : List[str] ): # Initialize image processor __UpperCAmelCase = self.image_processing_class(**self.image_processor_dict ) # create random PyTorch tensors __UpperCAmelCase = 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 __UpperCAmelCase = image_processing(image_inputs[0] , return_tensors='''pt''' ).pixel_values __UpperCAmelCase , __UpperCAmelCase = 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 __UpperCAmelCase = image_processing(_lowercase , return_tensors='''pt''' ).pixel_values __UpperCAmelCase , __UpperCAmelCase = 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, ) , )
332
"""simple docstring""" import numpy as np from numpy import ndarray from scipy.optimize import Bounds, LinearConstraint, minimize def lowercase__ ( snake_case_ :ndarray ): return np.dot(snake_case_ , snake_case_ ) class _UpperCAmelCase : def __init__( self : Union[str, Any] , *, _lowercase : float = np.inf , _lowercase : str = "linear" , _lowercase : float = 0.0 , ): __UpperCAmelCase = regularization __UpperCAmelCase = gamma if kernel == "linear": __UpperCAmelCase = self.__linear elif kernel == "rbf": if self.gamma == 0: raise ValueError('''rbf kernel requires gamma''' ) if not isinstance(self.gamma , (float, int) ): raise ValueError('''gamma must be float or int''' ) if not self.gamma > 0: raise ValueError('''gamma must be > 0''' ) __UpperCAmelCase = self.__rbf # in the future, there could be a default value like in sklearn # sklear: def_gamma = 1/(n_features * X.var()) (wiki) # previously it was 1/(n_features) else: __UpperCAmelCase = F'''Unknown kernel: {kernel}''' raise ValueError(_lowercase ) def a ( self : Dict , _lowercase : ndarray , _lowercase : ndarray ): return np.dot(_lowercase , _lowercase ) def a ( self : Any , _lowercase : ndarray , _lowercase : ndarray ): return np.exp(-(self.gamma * norm_squared(vectora - vectora )) ) def a ( self : Union[str, Any] , _lowercase : list[ndarray] , _lowercase : ndarray ): __UpperCAmelCase = observations __UpperCAmelCase = classes # using Wolfe's Dual to calculate w. # Primal problem: minimize 1/2*norm_squared(w) # constraint: yn(w . xn + b) >= 1 # # With l a vector # Dual problem: maximize sum_n(ln) - # 1/2 * sum_n(sum_m(ln*lm*yn*ym*xn . xm)) # constraint: self.C >= ln >= 0 # and sum_n(ln*yn) = 0 # Then we get w using w = sum_n(ln*yn*xn) # At the end we can get b ~= mean(yn - w . xn) # # Since we use kernels, we only need l_star to calculate b # and to classify observations ((__UpperCAmelCase) , ) = np.shape(_lowercase ) def to_minimize(_lowercase : ndarray ) -> float: __UpperCAmelCase = 0 ((__UpperCAmelCase) , ) = np.shape(_lowercase ) for i in range(_lowercase ): for j in range(_lowercase ): s += ( candidate[i] * candidate[j] * classes[i] * classes[j] * self.kernel(observations[i] , observations[j] ) ) return 1 / 2 * s - sum(_lowercase ) __UpperCAmelCase = LinearConstraint(_lowercase , 0 , 0 ) __UpperCAmelCase = Bounds(0 , self.regularization ) __UpperCAmelCase = minimize( _lowercase , np.ones(_lowercase ) , bounds=_lowercase , constraints=[ly_contraint] ).x __UpperCAmelCase = l_star # calculating mean offset of separation plane to points __UpperCAmelCase = 0 for i in range(_lowercase ): for j in range(_lowercase ): s += classes[i] - classes[i] * self.optimum[i] * self.kernel( observations[i] , observations[j] ) __UpperCAmelCase = s / n def a ( self : List[Any] , _lowercase : ndarray ): __UpperCAmelCase = sum( self.optimum[n] * self.classes[n] * self.kernel(self.observations[n] , _lowercase ) for n in range(len(self.classes ) ) ) return 1 if s + self.offset >= 0 else -1 if __name__ == "__main__": import doctest doctest.testmod()
332
1
"""simple docstring""" import random import unittest import numpy as np import torch from diffusers import ( DPMSolverMultistepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, LMSDiscreteScheduler, OnnxStableDiffusionUpscalePipeline, PNDMScheduler, ) from diffusers.utils import floats_tensor from diffusers.utils.testing_utils import ( is_onnx_available, load_image, nightly, require_onnxruntime, require_torch_gpu, ) from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin if is_onnx_available(): import onnxruntime as ort class _UpperCAmelCase ( _lowerCAmelCase , unittest.TestCase ): # TODO: is there an appropriate internal test set? a__ : int = "ssube/stable-diffusion-x4-upscaler-onnx" def a ( self : Any , _lowercase : Optional[int]=0 ): __UpperCAmelCase = floats_tensor((1, 3, 1_28, 1_28) , rng=random.Random(_lowercase ) ) __UpperCAmelCase = torch.manual_seed(_lowercase ) __UpperCAmelCase = { '''prompt''': '''A painting of a squirrel eating a burger''', '''image''': image, '''generator''': generator, '''num_inference_steps''': 3, '''guidance_scale''': 7.5, '''output_type''': '''numpy''', } return inputs def a ( self : Union[str, Any] ): __UpperCAmelCase = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''' ) pipe.set_progress_bar_config(disable=_lowercase ) __UpperCAmelCase = self.get_dummy_inputs() __UpperCAmelCase = pipe(**_lowercase ).images __UpperCAmelCase = image[0, -3:, -3:, -1].flatten() # started as 128, should now be 512 assert image.shape == (1, 5_12, 5_12, 3) __UpperCAmelCase = np.array( [0.6_974_782, 0.68_902_093, 0.70_135_885, 0.7_583_618, 0.7_804_545, 0.7_854_912, 0.78_667_426, 0.78_743_863, 0.78_070_223] ) assert np.abs(image_slice - expected_slice ).max() < 1E-1 def a ( self : str ): __UpperCAmelCase = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''' ) __UpperCAmelCase = PNDMScheduler.from_config(pipe.scheduler.config , skip_prk_steps=_lowercase ) pipe.set_progress_bar_config(disable=_lowercase ) __UpperCAmelCase = self.get_dummy_inputs() __UpperCAmelCase = pipe(**_lowercase ).images __UpperCAmelCase = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) __UpperCAmelCase = np.array( [0.6_898_892, 0.59_240_556, 0.52_499_527, 0.58_866_215, 0.52_258_235, 0.52_572_715, 0.62_414_473, 0.6_174_387, 0.6_214_964] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-1 def a ( self : Dict ): __UpperCAmelCase = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''' ) __UpperCAmelCase = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config ) pipe.set_progress_bar_config(disable=_lowercase ) __UpperCAmelCase = self.get_dummy_inputs() __UpperCAmelCase = pipe(**_lowercase ).images __UpperCAmelCase = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) __UpperCAmelCase = np.array( [0.7_659_278, 0.76_437_664, 0.75_579_107, 0.7_691_116, 0.77_666_986, 0.7_727_672, 0.7_758_664, 0.7_812_226, 0.76_942_515] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-1 def a ( self : Any ): __UpperCAmelCase = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''' ) __UpperCAmelCase = EulerDiscreteScheduler.from_config(pipe.scheduler.config ) pipe.set_progress_bar_config(disable=_lowercase ) __UpperCAmelCase = self.get_dummy_inputs() __UpperCAmelCase = pipe(**_lowercase ).images __UpperCAmelCase = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) __UpperCAmelCase = np.array( [0.6_974_782, 0.68_902_093, 0.70_135_885, 0.7_583_618, 0.7_804_545, 0.7_854_912, 0.78_667_426, 0.78_743_863, 0.78_070_223] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-1 def a ( self : Dict ): __UpperCAmelCase = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''' ) __UpperCAmelCase = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config ) pipe.set_progress_bar_config(disable=_lowercase ) __UpperCAmelCase = self.get_dummy_inputs() __UpperCAmelCase = pipe(**_lowercase ).images __UpperCAmelCase = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) __UpperCAmelCase = np.array( [0.77_424_496, 0.773_601, 0.7_645_288, 0.7_769_598, 0.7_772_739, 0.7_738_688, 0.78_187_233, 0.77_879_584, 0.767_043] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-1 @nightly @require_onnxruntime @require_torch_gpu class _UpperCAmelCase ( unittest.TestCase ): @property def a ( self : List[Any] ): return ( "CUDAExecutionProvider", { "gpu_mem_limit": "15000000000", # 15GB "arena_extend_strategy": "kSameAsRequested", }, ) @property def a ( self : Tuple ): __UpperCAmelCase = ort.SessionOptions() __UpperCAmelCase = False return options def a ( self : Any ): __UpperCAmelCase = load_image( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/img2img/sketch-mountains-input.jpg''' ) __UpperCAmelCase = init_image.resize((1_28, 1_28) ) # using the PNDM scheduler by default __UpperCAmelCase = OnnxStableDiffusionUpscalePipeline.from_pretrained( '''ssube/stable-diffusion-x4-upscaler-onnx''' , provider=self.gpu_provider , sess_options=self.gpu_options , ) pipe.set_progress_bar_config(disable=_lowercase ) __UpperCAmelCase = '''A fantasy landscape, trending on artstation''' __UpperCAmelCase = torch.manual_seed(0 ) __UpperCAmelCase = pipe( prompt=_lowercase , image=_lowercase , guidance_scale=7.5 , num_inference_steps=10 , generator=_lowercase , output_type='''np''' , ) __UpperCAmelCase = output.images __UpperCAmelCase = images[0, 2_55:2_58, 3_83:3_86, -1] assert images.shape == (1, 5_12, 5_12, 3) __UpperCAmelCase = np.array([0.4_883, 0.4_947, 0.4_980, 0.4_975, 0.4_982, 0.4_980, 0.5_000, 0.5_006, 0.4_972] ) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice ).max() < 2E-2 def a ( self : List[str] ): __UpperCAmelCase = load_image( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/img2img/sketch-mountains-input.jpg''' ) __UpperCAmelCase = init_image.resize((1_28, 1_28) ) __UpperCAmelCase = LMSDiscreteScheduler.from_pretrained( '''ssube/stable-diffusion-x4-upscaler-onnx''' , subfolder='''scheduler''' ) __UpperCAmelCase = OnnxStableDiffusionUpscalePipeline.from_pretrained( '''ssube/stable-diffusion-x4-upscaler-onnx''' , scheduler=_lowercase , provider=self.gpu_provider , sess_options=self.gpu_options , ) pipe.set_progress_bar_config(disable=_lowercase ) __UpperCAmelCase = '''A fantasy landscape, trending on artstation''' __UpperCAmelCase = torch.manual_seed(0 ) __UpperCAmelCase = pipe( prompt=_lowercase , image=_lowercase , guidance_scale=7.5 , num_inference_steps=20 , generator=_lowercase , output_type='''np''' , ) __UpperCAmelCase = output.images __UpperCAmelCase = images[0, 2_55:2_58, 3_83:3_86, -1] assert images.shape == (1, 5_12, 5_12, 3) __UpperCAmelCase = np.array( [0.50_173_753, 0.50_223_356, 0.502_039, 0.50_233_036, 0.5_023_725, 0.5_022_601, 0.5_018_758, 0.50_234_085, 0.50_241_566] ) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice ).max() < 2E-2
332
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import _LazyModule _lowercase : int = {'processing_wav2vec2_with_lm': ['Wav2Vec2ProcessorWithLM']} if TYPE_CHECKING: from .processing_wavaveca_with_lm import WavaVecaProcessorWithLM else: import sys _lowercase : Union[str, Any] = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
332
1
"""simple docstring""" from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging _lowercase : List[Any] = logging.get_logger(__name__) _lowercase : Optional[Any] = { 'roberta-base': 'https://huggingface.co/roberta-base/resolve/main/config.json', 'roberta-large': 'https://huggingface.co/roberta-large/resolve/main/config.json', 'roberta-large-mnli': 'https://huggingface.co/roberta-large-mnli/resolve/main/config.json', 'distilroberta-base': 'https://huggingface.co/distilroberta-base/resolve/main/config.json', 'roberta-base-openai-detector': 'https://huggingface.co/roberta-base-openai-detector/resolve/main/config.json', 'roberta-large-openai-detector': 'https://huggingface.co/roberta-large-openai-detector/resolve/main/config.json', } class _UpperCAmelCase ( _lowerCAmelCase ): a__ : Union[str, Any] = "roberta" def __init__( self : Tuple , _lowercase : Union[str, Any]=5_02_65 , _lowercase : List[Any]=7_68 , _lowercase : int=12 , _lowercase : Dict=12 , _lowercase : int=30_72 , _lowercase : List[str]="gelu" , _lowercase : Optional[int]=0.1 , _lowercase : List[Any]=0.1 , _lowercase : str=5_12 , _lowercase : Dict=2 , _lowercase : List[Any]=0.02 , _lowercase : List[Any]=1E-12 , _lowercase : Any=1 , _lowercase : int=0 , _lowercase : Union[str, Any]=2 , _lowercase : str="absolute" , _lowercase : Tuple=True , _lowercase : Tuple=None , **_lowercase : List[Any] , ): super().__init__(pad_token_id=_lowercase , bos_token_id=_lowercase , eos_token_id=_lowercase , **_lowercase ) __UpperCAmelCase = vocab_size __UpperCAmelCase = hidden_size __UpperCAmelCase = num_hidden_layers __UpperCAmelCase = num_attention_heads __UpperCAmelCase = hidden_act __UpperCAmelCase = intermediate_size __UpperCAmelCase = hidden_dropout_prob __UpperCAmelCase = attention_probs_dropout_prob __UpperCAmelCase = max_position_embeddings __UpperCAmelCase = type_vocab_size __UpperCAmelCase = initializer_range __UpperCAmelCase = layer_norm_eps __UpperCAmelCase = position_embedding_type __UpperCAmelCase = use_cache __UpperCAmelCase = classifier_dropout class _UpperCAmelCase ( _lowerCAmelCase ): @property def a ( self : Any ): if self.task == "multiple-choice": __UpperCAmelCase = {0: '''batch''', 1: '''choice''', 2: '''sequence'''} else: __UpperCAmelCase = {0: '''batch''', 1: '''sequence'''} return OrderedDict( [ ('''input_ids''', dynamic_axis), ('''attention_mask''', dynamic_axis), ] )
332
"""simple docstring""" from __future__ import annotations class _UpperCAmelCase : def __init__( self : Tuple , _lowercase : str , _lowercase : str ): __UpperCAmelCase , __UpperCAmelCase = text, pattern __UpperCAmelCase , __UpperCAmelCase = len(_lowercase ), len(_lowercase ) def a ( self : Optional[int] , _lowercase : str ): for i in range(self.patLen - 1 , -1 , -1 ): if char == self.pattern[i]: return i return -1 def a ( self : int , _lowercase : int ): for i in range(self.patLen - 1 , -1 , -1 ): if self.pattern[i] != self.text[current_pos + i]: return current_pos + i return -1 def a ( self : Optional[Any] ): # searches pattern in text and returns index positions __UpperCAmelCase = [] for i in range(self.textLen - self.patLen + 1 ): __UpperCAmelCase = self.mismatch_in_text(_lowercase ) if mismatch_index == -1: positions.append(_lowercase ) else: __UpperCAmelCase = self.match_in_pattern(self.text[mismatch_index] ) __UpperCAmelCase = ( mismatch_index - match_index ) # shifting index lgtm [py/multiple-definition] return positions _lowercase : str = 'ABAABA' _lowercase : Tuple = 'AB' _lowercase : Dict = BoyerMooreSearch(text, pattern) _lowercase : Any = bms.bad_character_heuristic() if len(positions) == 0: print('No match found') else: print('Pattern found in following positions: ') print(positions)
332
1
"""simple docstring""" from ...configuration_utils import PretrainedConfig from ...utils import logging _lowercase : List[Any] = logging.get_logger(__name__) _lowercase : List[str] = { 'caidas/swin2sr-classicalsr-x2-64': ( 'https://huggingface.co/caidas/swin2sr-classicalsr-x2-64/resolve/main/config.json' ), } class _UpperCAmelCase ( _lowerCAmelCase ): a__ : Tuple = "swin2sr" a__ : Dict = { "hidden_size": "embed_dim", "num_attention_heads": "num_heads", "num_hidden_layers": "num_layers", } def __init__( self : List[Any] , _lowercase : Tuple=64 , _lowercase : str=1 , _lowercase : Dict=3 , _lowercase : Dict=1_80 , _lowercase : List[str]=[6, 6, 6, 6, 6, 6] , _lowercase : Any=[6, 6, 6, 6, 6, 6] , _lowercase : str=8 , _lowercase : Union[str, Any]=2.0 , _lowercase : List[Any]=True , _lowercase : Union[str, Any]=0.0 , _lowercase : List[str]=0.0 , _lowercase : Any=0.1 , _lowercase : Tuple="gelu" , _lowercase : int=False , _lowercase : Tuple=0.02 , _lowercase : Tuple=1E-5 , _lowercase : int=2 , _lowercase : Any=1.0 , _lowercase : Any="1conv" , _lowercase : int="pixelshuffle" , **_lowercase : Optional[int] , ): super().__init__(**_lowercase ) __UpperCAmelCase = image_size __UpperCAmelCase = patch_size __UpperCAmelCase = num_channels __UpperCAmelCase = embed_dim __UpperCAmelCase = depths __UpperCAmelCase = len(_lowercase ) __UpperCAmelCase = num_heads __UpperCAmelCase = window_size __UpperCAmelCase = mlp_ratio __UpperCAmelCase = qkv_bias __UpperCAmelCase = hidden_dropout_prob __UpperCAmelCase = attention_probs_dropout_prob __UpperCAmelCase = drop_path_rate __UpperCAmelCase = hidden_act __UpperCAmelCase = use_absolute_embeddings __UpperCAmelCase = layer_norm_eps __UpperCAmelCase = initializer_range __UpperCAmelCase = upscale __UpperCAmelCase = img_range __UpperCAmelCase = resi_connection __UpperCAmelCase = upsampler
332
"""simple docstring""" from __future__ import annotations from collections import deque from collections.abc import Sequence from dataclasses import dataclass from typing import Any @dataclass class _UpperCAmelCase : a__ : int a__ : Node | None = None a__ : Node | None = None def lowercase__ ( ): __UpperCAmelCase = Node(1 ) __UpperCAmelCase = Node(2 ) __UpperCAmelCase = Node(3 ) __UpperCAmelCase = Node(4 ) __UpperCAmelCase = Node(5 ) return tree def lowercase__ ( snake_case_ :Node | None ): return [root.data, *preorder(root.left ), *preorder(root.right )] if root else [] def lowercase__ ( snake_case_ :Node | None ): return postorder(root.left ) + postorder(root.right ) + [root.data] if root else [] def lowercase__ ( snake_case_ :Node | None ): return [*inorder(root.left ), root.data, *inorder(root.right )] if root else [] def lowercase__ ( snake_case_ :Node | None ): return (max(height(root.left ) , height(root.right ) ) + 1) if root else 0 def lowercase__ ( snake_case_ :Node | None ): __UpperCAmelCase = [] if root is None: return output __UpperCAmelCase = deque([root] ) while process_queue: __UpperCAmelCase = process_queue.popleft() output.append(node.data ) if node.left: process_queue.append(node.left ) if node.right: process_queue.append(node.right ) return output def lowercase__ ( snake_case_ :Node | None , snake_case_ :int ): __UpperCAmelCase = [] def populate_output(snake_case_ :Node | None , snake_case_ :int ) -> None: if not root: return if level == 1: output.append(root.data ) elif level > 1: populate_output(root.left , level - 1 ) populate_output(root.right , level - 1 ) populate_output(snake_case_ , snake_case_ ) return output def lowercase__ ( snake_case_ :Node | None , snake_case_ :int ): __UpperCAmelCase = [] def populate_output(snake_case_ :Node | None , snake_case_ :int ) -> None: if root is None: return if level == 1: output.append(root.data ) elif level > 1: populate_output(root.right , level - 1 ) populate_output(root.left , level - 1 ) populate_output(snake_case_ , snake_case_ ) return output def lowercase__ ( snake_case_ :Node | None ): if root is None: return [] __UpperCAmelCase = [] __UpperCAmelCase = 0 __UpperCAmelCase = height(snake_case_ ) for h in range(1 , height_tree + 1 ): if not flag: output.append(get_nodes_from_left_to_right(snake_case_ , snake_case_ ) ) __UpperCAmelCase = 1 else: output.append(get_nodes_from_right_to_left(snake_case_ , snake_case_ ) ) __UpperCAmelCase = 0 return output def lowercase__ ( ): # Main function for testing. __UpperCAmelCase = make_tree() print(F'''In-order Traversal: {inorder(snake_case_ )}''' ) print(F'''Pre-order Traversal: {preorder(snake_case_ )}''' ) print(F'''Post-order Traversal: {postorder(snake_case_ )}''' , '''\n''' ) print(F'''Height of Tree: {height(snake_case_ )}''' , '''\n''' ) print('''Complete Level Order Traversal: ''' ) print(level_order(snake_case_ ) , '''\n''' ) print('''Level-wise order Traversal: ''' ) for level in range(1 , height(snake_case_ ) + 1 ): print(F'''Level {level}:''' , get_nodes_from_left_to_right(snake_case_ , level=snake_case_ ) ) print('''\nZigZag order Traversal: ''' ) print(zigzag(snake_case_ ) ) if __name__ == "__main__": import doctest doctest.testmod() main()
332
1
"""simple docstring""" def lowercase__ ( snake_case_ :int , snake_case_ :int ): if b == 0: return 1 if (b % 2) == 0: return actual_power(snake_case_ , int(b / 2 ) ) * actual_power(snake_case_ , int(b / 2 ) ) else: return a * actual_power(snake_case_ , int(b / 2 ) ) * actual_power(snake_case_ , int(b / 2 ) ) def lowercase__ ( snake_case_ :int , snake_case_ :int ): if b < 0: return 1 / actual_power(snake_case_ , snake_case_ ) return actual_power(snake_case_ , snake_case_ ) if __name__ == "__main__": print(power(-2, -3))
332
"""simple docstring""" import unittest from transformers import is_torch_available from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow if is_torch_available(): import torch from transformers import XLMRobertaModel @require_sentencepiece @require_tokenizers @require_torch class _UpperCAmelCase ( unittest.TestCase ): @slow def a ( self : str ): __UpperCAmelCase = XLMRobertaModel.from_pretrained('''xlm-roberta-base''' ) __UpperCAmelCase = torch.tensor([[0, 5_81, 1_02_69, 83, 9_99_42, 1_36, 6_07_42, 23, 70, 8_05_83, 1_82_76, 2]] ) # The dog is cute and lives in the garden house __UpperCAmelCase = torch.Size((1, 12, 7_68) ) # batch_size, sequence_length, embedding_vector_dim __UpperCAmelCase = torch.tensor( [[-0.0_101, 0.1_218, -0.0_803, 0.0_801, 0.1_327, 0.0_776, -0.1_215, 0.2_383, 0.3_338, 0.3_106, 0.0_300, 0.0_252]] ) # xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.base') # xlmr.eval() # expected_output_values_last_dim = xlmr.extract_features(input_ids[0])[:, :, -1] with torch.no_grad(): __UpperCAmelCase = model(_lowercase )['''last_hidden_state'''].detach() self.assertEqual(output.shape , _lowercase ) # compare the actual values for a slice of last dim self.assertTrue(torch.allclose(output[:, :, -1] , _lowercase , atol=1E-3 ) ) @slow def a ( self : str ): __UpperCAmelCase = XLMRobertaModel.from_pretrained('''xlm-roberta-large''' ) __UpperCAmelCase = torch.tensor([[0, 5_81, 1_02_69, 83, 9_99_42, 1_36, 6_07_42, 23, 70, 8_05_83, 1_82_76, 2]] ) # The dog is cute and lives in the garden house __UpperCAmelCase = torch.Size((1, 12, 10_24) ) # batch_size, sequence_length, embedding_vector_dim __UpperCAmelCase = torch.tensor( [[-0.0_699, -0.0_318, 0.0_705, -0.1_241, 0.0_999, -0.0_520, 0.1_004, -0.1_838, -0.4_704, 0.1_437, 0.0_821, 0.0_126]] ) # xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.large') # xlmr.eval() # expected_output_values_last_dim = xlmr.extract_features(input_ids[0])[:, :, -1] with torch.no_grad(): __UpperCAmelCase = model(_lowercase )['''last_hidden_state'''].detach() self.assertEqual(output.shape , _lowercase ) # compare the actual values for a slice of last dim self.assertTrue(torch.allclose(output[:, :, -1] , _lowercase , atol=1E-3 ) )
332
1
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_torch_available _lowercase : List[Any] = { 'configuration_gpt_neo': ['GPT_NEO_PRETRAINED_CONFIG_ARCHIVE_MAP', 'GPTNeoConfig', 'GPTNeoOnnxConfig'], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : int = [ 'GPT_NEO_PRETRAINED_MODEL_ARCHIVE_LIST', 'GPTNeoForCausalLM', 'GPTNeoForQuestionAnswering', 'GPTNeoForSequenceClassification', 'GPTNeoForTokenClassification', 'GPTNeoModel', 'GPTNeoPreTrainedModel', 'load_tf_weights_in_gpt_neo', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : str = [ 'FlaxGPTNeoForCausalLM', 'FlaxGPTNeoModel', 'FlaxGPTNeoPreTrainedModel', ] if TYPE_CHECKING: from .configuration_gpt_neo import GPT_NEO_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTNeoConfig, GPTNeoOnnxConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_gpt_neo import ( GPT_NEO_PRETRAINED_MODEL_ARCHIVE_LIST, GPTNeoForCausalLM, GPTNeoForQuestionAnswering, GPTNeoForSequenceClassification, GPTNeoForTokenClassification, GPTNeoModel, GPTNeoPreTrainedModel, load_tf_weights_in_gpt_neo, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_gpt_neo import FlaxGPTNeoForCausalLM, FlaxGPTNeoModel, FlaxGPTNeoPreTrainedModel else: import sys _lowercase : Dict = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
332
"""simple docstring""" def lowercase__ ( snake_case_ :Union[str, Any] ): # if the collection is empty, returns empty if collection == []: return [] # get some information about the collection __UpperCAmelCase = len(snake_case_ ) __UpperCAmelCase = max(snake_case_ ) __UpperCAmelCase = min(snake_case_ ) # create the counting array __UpperCAmelCase = coll_max + 1 - coll_min __UpperCAmelCase = [0] * counting_arr_length # count how much a number appears in the collection for number in collection: counting_arr[number - coll_min] += 1 # sum each position with it's predecessors. now, counting_arr[i] tells # us how many elements <= i has in the collection for i in range(1 , snake_case_ ): __UpperCAmelCase = counting_arr[i] + counting_arr[i - 1] # create the output collection __UpperCAmelCase = [0] * coll_len # place the elements in the output, respecting the original order (stable # sort) from end to begin, updating counting_arr for i in reversed(range(0 , snake_case_ ) ): __UpperCAmelCase = collection[i] counting_arr[collection[i] - coll_min] -= 1 return ordered def lowercase__ ( snake_case_ :str ): return "".join([chr(snake_case_ ) for i in counting_sort([ord(snake_case_ ) for c in string] )] ) if __name__ == "__main__": # Test string sort assert counting_sort_string('thisisthestring') == "eghhiiinrsssttt" _lowercase : int = input('Enter numbers separated by a comma:\n').strip() _lowercase : int = [int(item) for item in user_input.split(',')] print(counting_sort(unsorted))
332
1
"""simple docstring""" import argparse from pathlib import Path from typing import Dict, OrderedDict, Tuple import torch from audiocraft.models import MusicGen from transformers import ( AutoFeatureExtractor, AutoTokenizer, EncodecModel, MusicgenDecoderConfig, MusicgenForConditionalGeneration, MusicgenProcessor, TaEncoderModel, ) from transformers.models.musicgen.modeling_musicgen import MusicgenForCausalLM from transformers.utils import logging logging.set_verbosity_info() _lowercase : Dict = logging.get_logger(__name__) _lowercase : Dict = ['model.decoder.embed_positions.weights'] def lowercase__ ( snake_case_ :List[Any] ): if "emb" in name: __UpperCAmelCase = name.replace('''emb''' , '''model.decoder.embed_tokens''' ) if "transformer" in name: __UpperCAmelCase = name.replace('''transformer''' , '''model.decoder''' ) if "cross_attention" in name: __UpperCAmelCase = name.replace('''cross_attention''' , '''encoder_attn''' ) if "linear1" in name: __UpperCAmelCase = name.replace('''linear1''' , '''fc1''' ) if "linear2" in name: __UpperCAmelCase = name.replace('''linear2''' , '''fc2''' ) if "norm1" in name: __UpperCAmelCase = name.replace('''norm1''' , '''self_attn_layer_norm''' ) if "norm_cross" in name: __UpperCAmelCase = name.replace('''norm_cross''' , '''encoder_attn_layer_norm''' ) if "norm2" in name: __UpperCAmelCase = name.replace('''norm2''' , '''final_layer_norm''' ) if "out_norm" in name: __UpperCAmelCase = name.replace('''out_norm''' , '''model.decoder.layer_norm''' ) if "linears" in name: __UpperCAmelCase = name.replace('''linears''' , '''lm_heads''' ) if "condition_provider.conditioners.description.output_proj" in name: __UpperCAmelCase = name.replace('''condition_provider.conditioners.description.output_proj''' , '''enc_to_dec_proj''' ) return name def lowercase__ ( snake_case_ :OrderedDict , snake_case_ :int ): __UpperCAmelCase = list(state_dict.keys() ) __UpperCAmelCase = {} for key in keys: __UpperCAmelCase = state_dict.pop(snake_case_ ) __UpperCAmelCase = rename_keys(snake_case_ ) if "in_proj_weight" in key: # split fused qkv proj __UpperCAmelCase = val[:hidden_size, :] __UpperCAmelCase = val[hidden_size : 2 * hidden_size, :] __UpperCAmelCase = val[-hidden_size:, :] elif "enc_to_dec_proj" in key: __UpperCAmelCase = val else: __UpperCAmelCase = val return state_dict, enc_dec_proj_state_dict def lowercase__ ( snake_case_ :str ): if checkpoint == "small": # default config values __UpperCAmelCase = 1_024 __UpperCAmelCase = 24 __UpperCAmelCase = 16 elif checkpoint == "medium": __UpperCAmelCase = 1_536 __UpperCAmelCase = 48 __UpperCAmelCase = 24 elif checkpoint == "large": __UpperCAmelCase = 2_048 __UpperCAmelCase = 48 __UpperCAmelCase = 32 else: raise ValueError(F'''Checkpoint should be one of `[\'small\', \'medium\', \'large\']`, got {checkpoint}.''' ) __UpperCAmelCase = MusicgenDecoderConfig( hidden_size=snake_case_ , ffn_dim=hidden_size * 4 , num_hidden_layers=snake_case_ , num_attention_heads=snake_case_ , ) return config @torch.no_grad() def lowercase__ ( snake_case_ :int , snake_case_ :Optional[Any]=None , snake_case_ :Any=None , snake_case_ :Optional[int]="cpu" ): __UpperCAmelCase = MusicGen.get_pretrained(snake_case_ , device=snake_case_ ) __UpperCAmelCase = decoder_config_from_checkpoint(snake_case_ ) __UpperCAmelCase = fairseq_model.lm.state_dict() __UpperCAmelCase , __UpperCAmelCase = rename_state_dict( snake_case_ , hidden_size=decoder_config.hidden_size ) __UpperCAmelCase = TaEncoderModel.from_pretrained('''t5-base''' ) __UpperCAmelCase = EncodecModel.from_pretrained('''facebook/encodec_32khz''' ) __UpperCAmelCase = MusicgenForCausalLM(snake_case_ ).eval() # load all decoder weights - expect that we'll be missing embeddings and enc-dec projection __UpperCAmelCase , __UpperCAmelCase = decoder.load_state_dict(snake_case_ , strict=snake_case_ ) for key in missing_keys.copy(): if key.startswith(('''text_encoder''', '''audio_encoder''') ) or key in EXPECTED_MISSING_KEYS: missing_keys.remove(snake_case_ ) if len(snake_case_ ) > 0: raise ValueError(F'''Missing key(s) in state_dict: {missing_keys}''' ) if len(snake_case_ ) > 0: raise ValueError(F'''Unexpected key(s) in state_dict: {unexpected_keys}''' ) # init the composite model __UpperCAmelCase = MusicgenForConditionalGeneration(text_encoder=snake_case_ , audio_encoder=snake_case_ , decoder=snake_case_ ) # load the pre-trained enc-dec projection (from the decoder state dict) model.enc_to_dec_proj.load_state_dict(snake_case_ ) # check we can do a forward pass __UpperCAmelCase = torch.arange(0 , 8 , dtype=torch.long ).reshape(2 , -1 ) __UpperCAmelCase = input_ids.reshape(2 * 4 , -1 ) with torch.no_grad(): __UpperCAmelCase = model(input_ids=snake_case_ , decoder_input_ids=snake_case_ ).logits if logits.shape != (8, 1, 2_048): raise ValueError('''Incorrect shape for logits''' ) # now construct the processor __UpperCAmelCase = AutoTokenizer.from_pretrained('''t5-base''' ) __UpperCAmelCase = AutoFeatureExtractor.from_pretrained('''facebook/encodec_32khz''' , padding_side='''left''' ) __UpperCAmelCase = MusicgenProcessor(feature_extractor=snake_case_ , tokenizer=snake_case_ ) # set the appropriate bos/pad token ids __UpperCAmelCase = 2_048 __UpperCAmelCase = 2_048 # set other default generation config params __UpperCAmelCase = int(30 * audio_encoder.config.frame_rate ) __UpperCAmelCase = True __UpperCAmelCase = 3.0 if pytorch_dump_folder is not None: Path(snake_case_ ).mkdir(exist_ok=snake_case_ ) logger.info(F'''Saving model {checkpoint} to {pytorch_dump_folder}''' ) model.save_pretrained(snake_case_ ) processor.save_pretrained(snake_case_ ) if repo_id: logger.info(F'''Pushing model {checkpoint} to {repo_id}''' ) model.push_to_hub(snake_case_ ) processor.push_to_hub(snake_case_ ) if __name__ == "__main__": _lowercase : Tuple = argparse.ArgumentParser() # Required parameters parser.add_argument( '--checkpoint', default='small', type=str, help='Checkpoint size of the MusicGen model you\'d like to convert. Can be one of: `[\'small\', \'medium\', \'large\']`.', ) parser.add_argument( '--pytorch_dump_folder', required=True, default=None, type=str, help='Path to the output PyTorch model directory.', ) parser.add_argument( '--push_to_hub', default=None, type=str, help='Where to upload the converted model on the 🤗 hub.' ) parser.add_argument( '--device', default='cpu', type=str, help='Torch device to run the conversion, either cpu or cuda.' ) _lowercase : List[str] = parser.parse_args() convert_musicgen_checkpoint(args.checkpoint, args.pytorch_dump_folder, args.push_to_hub)
332
"""simple docstring""" from collections import defaultdict def lowercase__ ( snake_case_ :str , snake_case_ :str ): __UpperCAmelCase = first_str.lower().strip() __UpperCAmelCase = second_str.lower().strip() # Remove whitespace __UpperCAmelCase = first_str.replace(''' ''' , '''''' ) __UpperCAmelCase = second_str.replace(''' ''' , '''''' ) # Strings of different lengths are not anagrams if len(snake_case_ ) != len(snake_case_ ): return False # Default values for count should be 0 __UpperCAmelCase = defaultdict(snake_case_ ) # For each character in input strings, # increment count in the corresponding for i in range(len(snake_case_ ) ): 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() _lowercase : List[Any] = input('Enter the first string ').strip() _lowercase : Tuple = input('Enter the second string ').strip() _lowercase : str = check_anagrams(input_a, input_b) print(f"""{input_a} and {input_b} are {"" if status else "not "}anagrams.""")
332
1
"""simple docstring""" from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging _lowercase : Dict = logging.get_logger(__name__) _lowercase : Union[str, Any] = { 'facebook/xmod-base': 'https://huggingface.co/facebook/xmod-base/resolve/main/config.json', 'facebook/xmod-large-prenorm': 'https://huggingface.co/facebook/xmod-large-prenorm/resolve/main/config.json', 'facebook/xmod-base-13-125k': 'https://huggingface.co/facebook/xmod-base-13-125k/resolve/main/config.json', 'facebook/xmod-base-30-125k': 'https://huggingface.co/facebook/xmod-base-30-125k/resolve/main/config.json', 'facebook/xmod-base-30-195k': 'https://huggingface.co/facebook/xmod-base-30-195k/resolve/main/config.json', 'facebook/xmod-base-60-125k': 'https://huggingface.co/facebook/xmod-base-60-125k/resolve/main/config.json', 'facebook/xmod-base-60-265k': 'https://huggingface.co/facebook/xmod-base-60-265k/resolve/main/config.json', 'facebook/xmod-base-75-125k': 'https://huggingface.co/facebook/xmod-base-75-125k/resolve/main/config.json', 'facebook/xmod-base-75-269k': 'https://huggingface.co/facebook/xmod-base-75-269k/resolve/main/config.json', } class _UpperCAmelCase ( _lowerCAmelCase ): a__ : List[Any] = "xmod" def __init__( self : Tuple , _lowercase : Optional[Any]=3_05_22 , _lowercase : Optional[Any]=7_68 , _lowercase : List[str]=12 , _lowercase : List[Any]=12 , _lowercase : int=30_72 , _lowercase : Optional[Any]="gelu" , _lowercase : int=0.1 , _lowercase : List[str]=0.1 , _lowercase : List[str]=5_12 , _lowercase : int=2 , _lowercase : List[Any]=0.02 , _lowercase : int=1E-12 , _lowercase : int=1 , _lowercase : Any=0 , _lowercase : Any=2 , _lowercase : Optional[Any]="absolute" , _lowercase : List[str]=True , _lowercase : Optional[int]=None , _lowercase : int=False , _lowercase : str=2 , _lowercase : List[Any]=False , _lowercase : Tuple=True , _lowercase : Tuple=True , _lowercase : Optional[int]=("en_XX",) , _lowercase : List[str]=None , **_lowercase : str , ): super().__init__(pad_token_id=_lowercase , bos_token_id=_lowercase , eos_token_id=_lowercase , **_lowercase ) __UpperCAmelCase = vocab_size __UpperCAmelCase = hidden_size __UpperCAmelCase = num_hidden_layers __UpperCAmelCase = num_attention_heads __UpperCAmelCase = hidden_act __UpperCAmelCase = intermediate_size __UpperCAmelCase = hidden_dropout_prob __UpperCAmelCase = attention_probs_dropout_prob __UpperCAmelCase = max_position_embeddings __UpperCAmelCase = type_vocab_size __UpperCAmelCase = initializer_range __UpperCAmelCase = layer_norm_eps __UpperCAmelCase = position_embedding_type __UpperCAmelCase = use_cache __UpperCAmelCase = classifier_dropout __UpperCAmelCase = pre_norm __UpperCAmelCase = adapter_reduction_factor __UpperCAmelCase = adapter_layer_norm __UpperCAmelCase = adapter_reuse_layer_norm __UpperCAmelCase = ln_before_adapter __UpperCAmelCase = list(_lowercase ) __UpperCAmelCase = default_language class _UpperCAmelCase ( _lowerCAmelCase ): @property def a ( self : List[str] ): if self.task == "multiple-choice": __UpperCAmelCase = {0: '''batch''', 1: '''choice''', 2: '''sequence'''} else: __UpperCAmelCase = {0: '''batch''', 1: '''sequence'''} return OrderedDict( [ ('''input_ids''', dynamic_axis), ('''attention_mask''', dynamic_axis), ] )
332
"""simple docstring""" import os import tempfile import unittest from pathlib import Path from transformers import AutoConfig, is_torch_available from transformers.testing_utils import require_torch, torch_device if is_torch_available(): from transformers import PyTorchBenchmark, PyTorchBenchmarkArguments @require_torch class _UpperCAmelCase ( unittest.TestCase ): def a ( self : Dict , _lowercase : Union[str, Any] ): for model_result in results.values(): for batch_size, sequence_length in zip(model_result['''bs'''] , model_result['''ss'''] ): __UpperCAmelCase = model_result['''result'''][batch_size][sequence_length] self.assertIsNotNone(_lowercase ) def a ( self : str ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : List[str] ): __UpperCAmelCase = '''sgugger/tiny-distilbert-classification''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , only_pretrain_model=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : str ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , torchscript=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) @unittest.skipIf(torch_device == '''cpu''' , '''Cant do half precision''' ) def a ( self : Optional[Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , fpaa=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : int ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) # set architectures equal to `None` __UpperCAmelCase = None __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : Tuple ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) @unittest.skipIf(torch_device == '''cpu''' , '''Can\'t do half precision''' ) def a ( self : Optional[Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , fpaa=_lowercase , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) def a ( self : Any ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : str ): __UpperCAmelCase = '''sshleifer/tinier_bart''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : Union[str, Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) def a ( self : int ): __UpperCAmelCase = '''sshleifer/tinier_bart''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) def a ( self : Optional[Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' with tempfile.TemporaryDirectory() as tmp_dir: __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , save_to_csv=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , inference_time_csv_file=os.path.join(_lowercase , '''inf_time.csv''' ) , train_memory_csv_file=os.path.join(_lowercase , '''train_mem.csv''' ) , inference_memory_csv_file=os.path.join(_lowercase , '''inf_mem.csv''' ) , train_time_csv_file=os.path.join(_lowercase , '''train_time.csv''' ) , env_info_csv_file=os.path.join(_lowercase , '''env.csv''' ) , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) benchmark.run() self.assertTrue(Path(os.path.join(_lowercase , '''inf_time.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(_lowercase , '''train_time.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(_lowercase , '''inf_mem.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(_lowercase , '''train_mem.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(_lowercase , '''env.csv''' ) ).exists() ) def a ( self : List[Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' def _check_summary_is_not_empty(_lowercase : str ): self.assertTrue(hasattr(_lowercase , '''sequential''' ) ) self.assertTrue(hasattr(_lowercase , '''cumulative''' ) ) self.assertTrue(hasattr(_lowercase , '''current''' ) ) self.assertTrue(hasattr(_lowercase , '''total''' ) ) with tempfile.TemporaryDirectory() as tmp_dir: __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , log_filename=os.path.join(_lowercase , '''log.txt''' ) , log_print=_lowercase , trace_memory_line_by_line=_lowercase , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() _check_summary_is_not_empty(result.inference_summary ) _check_summary_is_not_empty(result.train_summary ) self.assertTrue(Path(os.path.join(_lowercase , '''log.txt''' ) ).exists() )
332
1
"""simple docstring""" from typing import List, Optional, Union import numpy as np import tensorflow as tf from .utils import logging _lowercase : List[str] = logging.get_logger(__name__) def lowercase__ ( snake_case_ :Union[tf.Tensor, np.ndarray] ): if isinstance(snake_case_ , np.ndarray ): return list(tensor.shape ) __UpperCAmelCase = tf.shape(snake_case_ ) if tensor.shape == tf.TensorShape(snake_case_ ): return dynamic __UpperCAmelCase = tensor.shape.as_list() return [dynamic[i] if s is None else s for i, s in enumerate(snake_case_ )] def lowercase__ ( snake_case_ :tf.Tensor , snake_case_ :Optional[int] = None , snake_case_ :Optional[str] = None ): return tf.nn.softmax(logits=logits + 1E-9 , axis=snake_case_ , name=snake_case_ ) def lowercase__ ( snake_case_ :int , snake_case_ :Union[str, Any] , snake_case_ :str , snake_case_ :Union[str, Any]=1E-5 , snake_case_ :List[str]=-1 ): # This is a very simplified functional layernorm, designed to duplicate # the functionality of PyTorch nn.functional.layer_norm when this is needed to port # models in Transformers. if weight.shape.rank != 1 or bias.shape.rank != 1 or not isinstance(snake_case_ , snake_case_ ): raise NotImplementedError('''Only 1D weight and bias tensors are supported for now, with only a single axis.''' ) # Get mean and variance on the axis to be normalized __UpperCAmelCase , __UpperCAmelCase = tf.nn.moments(snake_case_ , axes=[axis] , keepdims=snake_case_ ) if axis != -1: # Reshape scale and weight to have the same rank as inputs, but with 1 dimensions # on every dimension except axis __UpperCAmelCase = [1] * inputs.shape.rank __UpperCAmelCase = shape_list(snake_case_ )[axis] __UpperCAmelCase = tf.reshape(snake_case_ , snake_case_ ) __UpperCAmelCase = tf.reshape(snake_case_ , snake_case_ ) # Compute layer normalization using the batch_normalization # function. __UpperCAmelCase = tf.nn.batch_normalization( snake_case_ , snake_case_ , snake_case_ , offset=snake_case_ , scale=snake_case_ , variance_epsilon=snake_case_ , ) return outputs def lowercase__ ( snake_case_ :Optional[int] , snake_case_ :List[str]=0 , snake_case_ :Optional[Any]=-1 ): # Replicates the behavior of torch.flatten in TF # If end_dim or start_dim is negative, count them from the end if end_dim < 0: end_dim += input.shape.rank if start_dim < 0: start_dim += input.shape.rank if start_dim == end_dim: return input __UpperCAmelCase = tf.shape(snake_case_ ) __UpperCAmelCase = tf.math.reduce_prod(in_shape[start_dim : end_dim + 1] ) __UpperCAmelCase = tf.concat([in_shape[:start_dim], [flattened_dim], in_shape[end_dim + 1 :]] , axis=0 ) return tf.reshape(snake_case_ , snake_case_ ) def lowercase__ ( snake_case_ :tf.Tensor ): if not isinstance(snake_case_ , tf.Tensor ): __UpperCAmelCase = tf.convert_to_tensor(snake_case_ ) # Catches stray NumPy inputs if encoder_attention_mask.shape.rank == 3: __UpperCAmelCase = encoder_attention_mask[:, None, :, :] if encoder_attention_mask.shape.rank == 2: __UpperCAmelCase = encoder_attention_mask[:, None, None, :] # T5 has a mask that can compare sequence ids, we can simulate this here with this transposition # Cf. https://github.com/tensorflow/mesh/blob/8d2465e9bc93129b913b5ccc6a59aa97abd96ec6/mesh_tensorflow # /transformer/transformer_layers.py#L270 # encoder_extended_attention_mask = (encoder_extended_attention_mask == # encoder_extended_attention_mask.transpose(-1, -2)) __UpperCAmelCase = ( tf.cast(1 , encoder_attention_mask.dtype ) - encoder_extended_attention_mask ) * encoder_extended_attention_mask.dtype.min return encoder_extended_attention_mask def lowercase__ ( snake_case_ :tf.Tensor , snake_case_ :int , snake_case_ :str = "input_ids" ): tf.debugging.assert_less( snake_case_ , tf.cast(snake_case_ , dtype=tensor.dtype ) , message=( F'''The maximum value of {tensor_name} ({tf.math.reduce_max(snake_case_ )}) must be smaller than the embedding ''' F'''layer\'s input dimension ({embed_dim}). The likely cause is some problem at tokenization time.''' ) , ) def lowercase__ ( snake_case_ :List[Any] , snake_case_ :List[Any] , snake_case_ :List[str] ): __UpperCAmelCase = 64_512 # Check that no item in `data` is larger than `HDF5_OBJECT_HEADER_LIMIT` # because in that case even chunking the array would not make the saving # possible. __UpperCAmelCase = [x for x in data if len(snake_case_ ) > HDF5_OBJECT_HEADER_LIMIT] # Expecting this to never be true. if bad_attributes: raise RuntimeError( '''The following attributes cannot be saved to HDF5 file because ''' F'''they are larger than {HDF5_OBJECT_HEADER_LIMIT} ''' F'''bytes: {bad_attributes}''' ) __UpperCAmelCase = np.asarray(snake_case_ ) __UpperCAmelCase = 1 __UpperCAmelCase = np.array_split(snake_case_ , snake_case_ ) # This will never loop forever thanks to the test above. while any(x.nbytes > HDF5_OBJECT_HEADER_LIMIT for x in chunked_data ): num_chunks += 1 __UpperCAmelCase = np.array_split(snake_case_ , snake_case_ ) if num_chunks > 1: for chunk_id, chunk_data in enumerate(snake_case_ ): __UpperCAmelCase = chunk_data else: __UpperCAmelCase = data def lowercase__ ( snake_case_ :str , snake_case_ :List[str] ): if name in group.attrs: __UpperCAmelCase = [n.decode('''utf8''' ) if hasattr(snake_case_ , '''decode''' ) else n for n in group.attrs[name]] else: __UpperCAmelCase = [] __UpperCAmelCase = 0 while "%s%d" % (name, chunk_id) in group.attrs: data.extend( [n.decode('''utf8''' ) if hasattr(snake_case_ , '''decode''' ) else n for n in group.attrs['''%s%d''' % (name, chunk_id)]] ) chunk_id += 1 return data def lowercase__ ( snake_case_ :Tuple ): def _expand_single_ad_tensor(snake_case_ :Optional[int] ): if isinstance(snake_case_ , tf.Tensor ) and t.shape.rank == 1: return tf.expand_dims(snake_case_ , axis=-1 ) return t return tf.nest.map_structure(_expand_single_ad_tensor , snake_case_ )
332
"""simple docstring""" from typing import Dict from .base import GenericTensor, Pipeline class _UpperCAmelCase ( _lowerCAmelCase ): def a ( self : Tuple , _lowercase : Dict=None , _lowercase : str=None , _lowercase : Union[str, Any]=None , **_lowercase : Tuple ): if tokenize_kwargs is None: __UpperCAmelCase = {} if truncation is not None: if "truncation" in tokenize_kwargs: raise ValueError( '''truncation parameter defined twice (given as keyword argument as well as in tokenize_kwargs)''' ) __UpperCAmelCase = truncation __UpperCAmelCase = tokenize_kwargs __UpperCAmelCase = {} if return_tensors is not None: __UpperCAmelCase = return_tensors return preprocess_params, {}, postprocess_params def a ( self : int , _lowercase : Optional[Any] , **_lowercase : Union[str, Any] ): __UpperCAmelCase = self.framework __UpperCAmelCase = self.tokenizer(_lowercase , return_tensors=_lowercase , **_lowercase ) return model_inputs def a ( self : List[str] , _lowercase : Tuple ): __UpperCAmelCase = self.model(**_lowercase ) return model_outputs def a ( self : int , _lowercase : Tuple , _lowercase : str=False ): # [0] is the first available tensor, logits or last_hidden_state. if return_tensors: return model_outputs[0] if self.framework == "pt": return model_outputs[0].tolist() elif self.framework == "tf": return model_outputs[0].numpy().tolist() def __call__( self : List[Any] , *_lowercase : Optional[Any] , **_lowercase : Union[str, Any] ): return super().__call__(*_lowercase , **_lowercase )
332
1
"""simple docstring""" import gc import random import tempfile import unittest import numpy as np import torch from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel from diffusers.pipelines.stable_diffusion_safe import StableDiffusionPipelineSafe as StableDiffusionPipeline from diffusers.utils import floats_tensor, nightly, torch_device from diffusers.utils.testing_utils import require_torch_gpu class _UpperCAmelCase ( unittest.TestCase ): def a ( self : Tuple ): # clean up the VRAM after each test super().tearDown() gc.collect() torch.cuda.empty_cache() @property def a ( self : Optional[int] ): __UpperCAmelCase = 1 __UpperCAmelCase = 3 __UpperCAmelCase = (32, 32) __UpperCAmelCase = floats_tensor((batch_size, num_channels) + sizes , rng=random.Random(0 ) ).to(_lowercase ) return image @property def a ( self : List[str] ): torch.manual_seed(0 ) __UpperCAmelCase = UNetaDConditionModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=4 , out_channels=4 , down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''') , up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''') , cross_attention_dim=32 , ) return model @property def a ( self : List[str] ): torch.manual_seed(0 ) __UpperCAmelCase = AutoencoderKL( block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D'''] , up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D'''] , latent_channels=4 , ) return model @property def a ( self : Dict ): torch.manual_seed(0 ) __UpperCAmelCase = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1E-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=10_00 , ) return CLIPTextModel(_lowercase ) @property def a ( self : List[str] ): def extract(*_lowercase : Union[str, Any] , **_lowercase : Any ): class _UpperCAmelCase : def __init__( self : Optional[int] ): __UpperCAmelCase = torch.ones([0] ) def a ( self : Optional[int] , _lowercase : List[Any] ): self.pixel_values.to(_lowercase ) return self return Out() return extract def a ( self : Dict ): __UpperCAmelCase = '''cpu''' # ensure determinism for the device-dependent torch.Generator __UpperCAmelCase = self.dummy_cond_unet __UpperCAmelCase = DDIMScheduler( beta_start=0.00_085 , beta_end=0.012 , beta_schedule='''scaled_linear''' , clip_sample=_lowercase , set_alpha_to_one=_lowercase , ) __UpperCAmelCase = self.dummy_vae __UpperCAmelCase = self.dummy_text_encoder __UpperCAmelCase = CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''' ) # make sure here that pndm scheduler skips prk __UpperCAmelCase = StableDiffusionPipeline( unet=_lowercase , scheduler=_lowercase , vae=_lowercase , text_encoder=_lowercase , tokenizer=_lowercase , safety_checker=_lowercase , feature_extractor=self.dummy_extractor , ) __UpperCAmelCase = sd_pipe.to(_lowercase ) sd_pipe.set_progress_bar_config(disable=_lowercase ) __UpperCAmelCase = '''A painting of a squirrel eating a burger''' __UpperCAmelCase = torch.Generator(device=_lowercase ).manual_seed(0 ) __UpperCAmelCase = sd_pipe([prompt] , generator=_lowercase , guidance_scale=6.0 , num_inference_steps=2 , output_type='''np''' ) __UpperCAmelCase = output.images __UpperCAmelCase = torch.Generator(device=_lowercase ).manual_seed(0 ) __UpperCAmelCase = sd_pipe( [prompt] , generator=_lowercase , guidance_scale=6.0 , num_inference_steps=2 , output_type='''np''' , return_dict=_lowercase , )[0] __UpperCAmelCase = image[0, -3:, -3:, -1] __UpperCAmelCase = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) __UpperCAmelCase = np.array([0.5_756, 0.6_118, 0.5_005, 0.5_041, 0.5_471, 0.4_726, 0.4_976, 0.4_865, 0.4_864] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2 assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1E-2 def a ( self : int ): __UpperCAmelCase = '''cpu''' # ensure determinism for the device-dependent torch.Generator __UpperCAmelCase = self.dummy_cond_unet __UpperCAmelCase = PNDMScheduler(skip_prk_steps=_lowercase ) __UpperCAmelCase = self.dummy_vae __UpperCAmelCase = self.dummy_text_encoder __UpperCAmelCase = CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''' ) # make sure here that pndm scheduler skips prk __UpperCAmelCase = StableDiffusionPipeline( unet=_lowercase , scheduler=_lowercase , vae=_lowercase , text_encoder=_lowercase , tokenizer=_lowercase , safety_checker=_lowercase , feature_extractor=self.dummy_extractor , ) __UpperCAmelCase = sd_pipe.to(_lowercase ) sd_pipe.set_progress_bar_config(disable=_lowercase ) __UpperCAmelCase = '''A painting of a squirrel eating a burger''' __UpperCAmelCase = torch.Generator(device=_lowercase ).manual_seed(0 ) __UpperCAmelCase = sd_pipe([prompt] , generator=_lowercase , guidance_scale=6.0 , num_inference_steps=2 , output_type='''np''' ) __UpperCAmelCase = output.images __UpperCAmelCase = torch.Generator(device=_lowercase ).manual_seed(0 ) __UpperCAmelCase = sd_pipe( [prompt] , generator=_lowercase , guidance_scale=6.0 , num_inference_steps=2 , output_type='''np''' , return_dict=_lowercase , )[0] __UpperCAmelCase = image[0, -3:, -3:, -1] __UpperCAmelCase = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) __UpperCAmelCase = np.array([0.5_125, 0.5_716, 0.4_828, 0.5_060, 0.5_650, 0.4_768, 0.5_185, 0.4_895, 0.4_993] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2 assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1E-2 def a ( self : str ): __UpperCAmelCase = StableDiffusionPipeline.from_pretrained( '''hf-internal-testing/tiny-stable-diffusion-lms-pipe''' , safety_checker=_lowercase ) assert isinstance(_lowercase , _lowercase ) assert isinstance(pipe.scheduler , _lowercase ) assert pipe.safety_checker is None __UpperCAmelCase = pipe('''example prompt''' , num_inference_steps=2 ).images[0] assert image is not None # check that there's no error when saving a pipeline with one of the models being None with tempfile.TemporaryDirectory() as tmpdirname: pipe.save_pretrained(_lowercase ) __UpperCAmelCase = StableDiffusionPipeline.from_pretrained(_lowercase ) # sanity check that the pipeline still works assert pipe.safety_checker is None __UpperCAmelCase = pipe('''example prompt''' , num_inference_steps=2 ).images[0] assert image is not None @unittest.skipIf(torch_device != '''cuda''' , '''This test requires a GPU''' ) def a ( self : Optional[Any] ): __UpperCAmelCase = self.dummy_cond_unet __UpperCAmelCase = PNDMScheduler(skip_prk_steps=_lowercase ) __UpperCAmelCase = self.dummy_vae __UpperCAmelCase = self.dummy_text_encoder __UpperCAmelCase = CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''' ) # put models in fp16 __UpperCAmelCase = unet.half() __UpperCAmelCase = vae.half() __UpperCAmelCase = bert.half() # make sure here that pndm scheduler skips prk __UpperCAmelCase = StableDiffusionPipeline( unet=_lowercase , scheduler=_lowercase , vae=_lowercase , text_encoder=_lowercase , tokenizer=_lowercase , safety_checker=_lowercase , feature_extractor=self.dummy_extractor , ) __UpperCAmelCase = sd_pipe.to(_lowercase ) sd_pipe.set_progress_bar_config(disable=_lowercase ) __UpperCAmelCase = '''A painting of a squirrel eating a burger''' __UpperCAmelCase = sd_pipe([prompt] , num_inference_steps=2 , output_type='''np''' ).images assert image.shape == (1, 64, 64, 3) @nightly @require_torch_gpu class _UpperCAmelCase ( unittest.TestCase ): def a ( self : Tuple ): # clean up the VRAM after each test super().tearDown() gc.collect() torch.cuda.empty_cache() def a ( self : Any ): __UpperCAmelCase = StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5''' , safety_checker=_lowercase ) __UpperCAmelCase = LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config ) __UpperCAmelCase = sd_pipe.to(_lowercase ) sd_pipe.set_progress_bar_config(disable=_lowercase ) __UpperCAmelCase = ( '''portrait of girl with smokey eyes makeup in abandoned hotel, grange clothes, redshift, wide high angle''' ''' coloured polaroid photograph with flash, kodak film, hyper real, stunning moody cinematography, with''' ''' anamorphic lenses, by maripol, fallen angels by wong kar - wai, style of suspiria and neon demon and''' ''' children from bahnhof zoo, detailed ''' ) __UpperCAmelCase = 40_03_66_03_46 __UpperCAmelCase = 7 # without safety guidance (sld_guidance_scale = 0) __UpperCAmelCase = torch.manual_seed(_lowercase ) __UpperCAmelCase = sd_pipe( [prompt] , generator=_lowercase , guidance_scale=_lowercase , num_inference_steps=50 , output_type='''np''' , width=5_12 , height=5_12 , sld_guidance_scale=0 , ) __UpperCAmelCase = output.images __UpperCAmelCase = image[0, -3:, -3:, -1] __UpperCAmelCase = [0.2_278, 0.2_231, 0.2_249, 0.2_333, 0.2_303, 0.1_885, 0.2_273, 0.2_144, 0.2_176] assert image.shape == (1, 5_12, 5_12, 3) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2 # without safety guidance (strong configuration) __UpperCAmelCase = torch.manual_seed(_lowercase ) __UpperCAmelCase = sd_pipe( [prompt] , generator=_lowercase , guidance_scale=_lowercase , num_inference_steps=50 , output_type='''np''' , width=5_12 , height=5_12 , sld_guidance_scale=20_00 , sld_warmup_steps=7 , sld_threshold=0.025 , sld_momentum_scale=0.5 , sld_mom_beta=0.7 , ) __UpperCAmelCase = output.images __UpperCAmelCase = image[0, -3:, -3:, -1] __UpperCAmelCase = [0.2_383, 0.2_276, 0.236, 0.2_192, 0.2_186, 0.2_053, 0.1_971, 0.1_901, 0.1_719] assert image.shape == (1, 5_12, 5_12, 3) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2 def a ( self : List[str] ): __UpperCAmelCase = StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5''' , safety_checker=_lowercase ) __UpperCAmelCase = LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config ) __UpperCAmelCase = sd_pipe.to(_lowercase ) sd_pipe.set_progress_bar_config(disable=_lowercase ) __UpperCAmelCase = '''padme amidala taking a bath artwork, safe for work, no nudity''' __UpperCAmelCase = 27_34_97_17_55 __UpperCAmelCase = 7 __UpperCAmelCase = torch.manual_seed(_lowercase ) __UpperCAmelCase = sd_pipe( [prompt] , generator=_lowercase , guidance_scale=_lowercase , num_inference_steps=50 , output_type='''np''' , width=5_12 , height=5_12 , sld_guidance_scale=0 , ) __UpperCAmelCase = output.images __UpperCAmelCase = image[0, -3:, -3:, -1] __UpperCAmelCase = [0.3_502, 0.3_622, 0.3_396, 0.3_642, 0.3_478, 0.3_318, 0.35, 0.3_348, 0.3_297] assert image.shape == (1, 5_12, 5_12, 3) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2 __UpperCAmelCase = torch.manual_seed(_lowercase ) __UpperCAmelCase = sd_pipe( [prompt] , generator=_lowercase , guidance_scale=_lowercase , num_inference_steps=50 , output_type='''np''' , width=5_12 , height=5_12 , sld_guidance_scale=20_00 , sld_warmup_steps=7 , sld_threshold=0.025 , sld_momentum_scale=0.5 , sld_mom_beta=0.7 , ) __UpperCAmelCase = output.images __UpperCAmelCase = image[0, -3:, -3:, -1] __UpperCAmelCase = [0.5_531, 0.5_206, 0.4_895, 0.5_156, 0.5_182, 0.4_751, 0.4_802, 0.4_803, 0.4_443] assert image.shape == (1, 5_12, 5_12, 3) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2 def a ( self : Tuple ): __UpperCAmelCase = StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5''' ) __UpperCAmelCase = sd_pipe.to(_lowercase ) sd_pipe.set_progress_bar_config(disable=_lowercase ) __UpperCAmelCase = ( '''the four horsewomen of the apocalypse, painting by tom of finland, gaston bussiere, craig mullins, j. c.''' ''' leyendecker''' ) __UpperCAmelCase = 10_44_35_52_34 __UpperCAmelCase = 12 __UpperCAmelCase = torch.manual_seed(_lowercase ) __UpperCAmelCase = sd_pipe( [prompt] , generator=_lowercase , guidance_scale=_lowercase , num_inference_steps=50 , output_type='''np''' , width=5_12 , height=5_12 , sld_guidance_scale=0 , ) __UpperCAmelCase = output.images __UpperCAmelCase = image[0, -3:, -3:, -1] __UpperCAmelCase = np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] ) assert image.shape == (1, 5_12, 5_12, 3) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-7 __UpperCAmelCase = torch.manual_seed(_lowercase ) __UpperCAmelCase = sd_pipe( [prompt] , generator=_lowercase , guidance_scale=_lowercase , num_inference_steps=50 , output_type='''np''' , width=5_12 , height=5_12 , sld_guidance_scale=20_00 , sld_warmup_steps=7 , sld_threshold=0.025 , sld_momentum_scale=0.5 , sld_mom_beta=0.7 , ) __UpperCAmelCase = output.images __UpperCAmelCase = image[0, -3:, -3:, -1] __UpperCAmelCase = np.array([0.5_818, 0.6_285, 0.6_835, 0.6_019, 0.625, 0.6_754, 0.6_096, 0.6_334, 0.6_561] ) assert image.shape == (1, 5_12, 5_12, 3) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2
332
"""simple docstring""" from typing import List, Optional, Tuple, Union import PIL import torch from torchvision import transforms from diffusers.pipeline_utils import DiffusionPipeline, ImagePipelineOutput from diffusers.schedulers import DDIMScheduler from diffusers.utils import randn_tensor _lowercase : Union[str, Any] = transforms.Compose( [ transforms.Resize((2_56, 2_56)), transforms.ToTensor(), transforms.Normalize([0.5], [0.5]), ] ) def lowercase__ ( snake_case_ :List[Any] ): if isinstance(snake_case_ , torch.Tensor ): return image elif isinstance(snake_case_ , PIL.Image.Image ): __UpperCAmelCase = [image] __UpperCAmelCase = [trans(img.convert('''RGB''' ) ) for img in image] __UpperCAmelCase = torch.stack(snake_case_ ) return image class _UpperCAmelCase ( _lowerCAmelCase ): def __init__( self : Any , _lowercase : str , _lowercase : str ): super().__init__() # make sure scheduler can always be converted to DDIM __UpperCAmelCase = DDIMScheduler.from_config(scheduler.config ) self.register_modules(unet=_lowercase , scheduler=_lowercase ) def a ( self : int , _lowercase : List[str] ): if strength < 0 or strength > 1: raise ValueError(F'''The value of strength should in [0.0, 1.0] but is {strength}''' ) def a ( self : List[Any] , _lowercase : List[Any] , _lowercase : Optional[Any] , _lowercase : int ): # get the original timestep using init_timestep __UpperCAmelCase = min(int(num_inference_steps * strength ) , _lowercase ) __UpperCAmelCase = max(num_inference_steps - init_timestep , 0 ) __UpperCAmelCase = self.scheduler.timesteps[t_start:] return timesteps, num_inference_steps - t_start def a ( self : Optional[Any] , _lowercase : Union[str, Any] , _lowercase : Union[str, Any] , _lowercase : Optional[Any] , _lowercase : List[str] , _lowercase : Tuple , _lowercase : Optional[int]=None ): if not isinstance(_lowercase , (torch.Tensor, PIL.Image.Image, list) ): raise ValueError( F'''`image` has to be of type `torch.Tensor`, `PIL.Image.Image` or list but is {type(_lowercase )}''' ) __UpperCAmelCase = image.to(device=_lowercase , dtype=_lowercase ) 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.''' ) __UpperCAmelCase = init_latents.shape __UpperCAmelCase = randn_tensor(_lowercase , generator=_lowercase , device=_lowercase , dtype=_lowercase ) # get latents print('''add noise to latents at timestep''' , _lowercase ) __UpperCAmelCase = self.scheduler.add_noise(_lowercase , _lowercase , _lowercase ) __UpperCAmelCase = init_latents return latents @torch.no_grad() def __call__( self : Any , _lowercase : Union[torch.FloatTensor, PIL.Image.Image] = None , _lowercase : float = 0.8 , _lowercase : int = 1 , _lowercase : Optional[Union[torch.Generator, List[torch.Generator]]] = None , _lowercase : float = 0.0 , _lowercase : int = 50 , _lowercase : Optional[bool] = None , _lowercase : Optional[str] = "pil" , _lowercase : bool = True , ): self.check_inputs(_lowercase ) # 2. Preprocess image __UpperCAmelCase = preprocess(_lowercase ) # 3. set timesteps self.scheduler.set_timesteps(_lowercase , device=self.device ) __UpperCAmelCase , __UpperCAmelCase = self.get_timesteps(_lowercase , _lowercase , self.device ) __UpperCAmelCase = timesteps[:1].repeat(_lowercase ) # 4. Prepare latent variables __UpperCAmelCase = self.prepare_latents(_lowercase , _lowercase , _lowercase , self.unet.dtype , self.device , _lowercase ) __UpperCAmelCase = latents # 5. Denoising loop for t in self.progress_bar(_lowercase ): # 1. predict noise model_output __UpperCAmelCase = 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 __UpperCAmelCase = self.scheduler.step( _lowercase , _lowercase , _lowercase , eta=_lowercase , use_clipped_model_output=_lowercase , generator=_lowercase , ).prev_sample __UpperCAmelCase = (image / 2 + 0.5).clamp(0 , 1 ) __UpperCAmelCase = image.cpu().permute(0 , 2 , 3 , 1 ).numpy() if output_type == "pil": __UpperCAmelCase = self.numpy_to_pil(_lowercase ) if not return_dict: return (image, latent_timestep.item()) return ImagePipelineOutput(images=_lowercase )
332
1
"""simple docstring""" def lowercase__ ( snake_case_ :str ): __UpperCAmelCase = [0 for i in range(len(snake_case_ ) )] # initialize interval's left pointer and right pointer __UpperCAmelCase , __UpperCAmelCase = 0, 0 for i in range(1 , len(snake_case_ ) ): # case when current index is inside the interval if i <= right_pointer: __UpperCAmelCase = min(right_pointer - i + 1 , z_result[i - left_pointer] ) __UpperCAmelCase = min_edge while go_next(snake_case_ , snake_case_ , snake_case_ ): z_result[i] += 1 # if new index's result gives us more right interval, # we've to update left_pointer and right_pointer if i + z_result[i] - 1 > right_pointer: __UpperCAmelCase , __UpperCAmelCase = i, i + z_result[i] - 1 return z_result def lowercase__ ( snake_case_ :int , snake_case_ :list[int] , snake_case_ :str ): return i + z_result[i] < len(snake_case_ ) and s[z_result[i]] == s[i + z_result[i]] def lowercase__ ( snake_case_ :str , snake_case_ :str ): __UpperCAmelCase = 0 # concatenate 'pattern' and 'input_str' and call z_function # with concatenated string __UpperCAmelCase = z_function(pattern + input_str ) for val in z_result: # if value is greater then length of the pattern string # that means this index is starting position of substring # which is equal to pattern string if val >= len(snake_case_ ): answer += 1 return answer if __name__ == "__main__": import doctest doctest.testmod()
332
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, ) _lowercase : Union[str, Any] = { 'configuration_resnet': ['RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ResNetConfig', 'ResNetOnnxConfig'] } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : int = [ 'RESNET_PRETRAINED_MODEL_ARCHIVE_LIST', 'ResNetForImageClassification', 'ResNetModel', 'ResNetPreTrainedModel', 'ResNetBackbone', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : Union[str, Any] = [ 'TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST', 'TFResNetForImageClassification', 'TFResNetModel', 'TFResNetPreTrainedModel', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : Optional[int] = [ '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 _lowercase : Dict = _LazyModule(__name__, globals()['__file__'], _import_structure)
332
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 _lowercase : Dict = get_logger(__name__) def lowercase__ ( snake_case_ :int , snake_case_ :Dict , snake_case_ :Union[str, Any] , snake_case_ :Tuple , snake_case_ :str=0 ): os.makedirs(snake_case_ , exist_ok=snake_case_ ) with FSDP.state_dict_type( snake_case_ , fsdp_plugin.state_dict_type , fsdp_plugin.state_dict_config , fsdp_plugin.optim_state_dict_config ): __UpperCAmelCase = model.state_dict() if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT: __UpperCAmelCase = F'''{MODEL_NAME}.bin''' if model_index == 0 else F'''{MODEL_NAME}_{model_index}.bin''' __UpperCAmelCase = os.path.join(snake_case_ , snake_case_ ) if accelerator.process_index == 0: logger.info(F'''Saving model to {output_model_file}''' ) torch.save(snake_case_ , snake_case_ ) logger.info(F'''Model saved to {output_model_file}''' ) elif fsdp_plugin.state_dict_type == StateDictType.LOCAL_STATE_DICT: __UpperCAmelCase = ( F'''{MODEL_NAME}_rank{accelerator.process_index}.bin''' if model_index == 0 else F'''{MODEL_NAME}_{model_index}_rank{accelerator.process_index}.bin''' ) __UpperCAmelCase = os.path.join(snake_case_ , snake_case_ ) logger.info(F'''Saving model to {output_model_file}''' ) torch.save(snake_case_ , snake_case_ ) logger.info(F'''Model saved to {output_model_file}''' ) elif fsdp_plugin.state_dict_type == StateDictType.SHARDED_STATE_DICT: __UpperCAmelCase = os.path.join(snake_case_ , F'''{MODEL_NAME}_{model_index}''' ) os.makedirs(snake_case_ , exist_ok=snake_case_ ) logger.info(F'''Saving model to {ckpt_dir}''' ) __UpperCAmelCase = {'''model''': state_dict} dist_cp.save_state_dict( state_dict=snake_case_ , storage_writer=dist_cp.FileSystemWriter(snake_case_ ) , planner=DefaultSavePlanner() , ) logger.info(F'''Model saved to {ckpt_dir}''' ) def lowercase__ ( snake_case_ :List[str] , snake_case_ :Dict , snake_case_ :Dict , snake_case_ :Union[str, Any] , snake_case_ :Optional[Any]=0 ): accelerator.wait_for_everyone() with FSDP.state_dict_type( snake_case_ , 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(snake_case_ ) != 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 = F'''{MODEL_NAME}.bin''' if model_index == 0 else F'''{MODEL_NAME}_{model_index}.bin''' __UpperCAmelCase = os.path.join(snake_case_ , snake_case_ ) logger.info(F'''Loading model from {input_model_file}''' ) __UpperCAmelCase = torch.load(snake_case_ ) logger.info(F'''Model loaded from {input_model_file}''' ) elif fsdp_plugin.state_dict_type == StateDictType.LOCAL_STATE_DICT: __UpperCAmelCase = ( F'''{MODEL_NAME}_rank{accelerator.process_index}.bin''' if model_index == 0 else F'''{MODEL_NAME}_{model_index}_rank{accelerator.process_index}.bin''' ) __UpperCAmelCase = os.path.join(snake_case_ , snake_case_ ) logger.info(F'''Loading model from {input_model_file}''' ) __UpperCAmelCase = torch.load(snake_case_ ) logger.info(F'''Model loaded from {input_model_file}''' ) elif fsdp_plugin.state_dict_type == StateDictType.SHARDED_STATE_DICT: __UpperCAmelCase = ( os.path.join(snake_case_ , 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 = {'''model''': model.state_dict()} dist_cp.load_state_dict( state_dict=snake_case_ , storage_reader=dist_cp.FileSystemReader(snake_case_ ) , planner=DefaultLoadPlanner() , ) __UpperCAmelCase = state_dict['''model'''] logger.info(F'''Model loaded from {ckpt_dir}''' ) model.load_state_dict(snake_case_ ) def lowercase__ ( snake_case_ :Tuple , snake_case_ :Optional[Any] , snake_case_ :str , snake_case_ :Tuple , snake_case_ :Dict , snake_case_ :Any=0 ): os.makedirs(snake_case_ , exist_ok=snake_case_ ) with FSDP.state_dict_type( snake_case_ , fsdp_plugin.state_dict_type , fsdp_plugin.state_dict_config , fsdp_plugin.optim_state_dict_config ): __UpperCAmelCase = FSDP.optim_state_dict(snake_case_ , snake_case_ ) if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT: if accelerator.process_index == 0: __UpperCAmelCase = ( F'''{OPTIMIZER_NAME}.bin''' if optimizer_index == 0 else F'''{OPTIMIZER_NAME}_{optimizer_index}.bin''' ) __UpperCAmelCase = os.path.join(snake_case_ , snake_case_ ) logger.info(F'''Saving Optimizer state to {output_optimizer_file}''' ) torch.save(snake_case_ , snake_case_ ) logger.info(F'''Optimizer state saved in {output_optimizer_file}''' ) else: __UpperCAmelCase = os.path.join(snake_case_ , F'''{OPTIMIZER_NAME}_{optimizer_index}''' ) os.makedirs(snake_case_ , exist_ok=snake_case_ ) logger.info(F'''Saving Optimizer state to {ckpt_dir}''' ) dist_cp.save_state_dict( state_dict={'''optimizer''': optim_state} , storage_writer=dist_cp.FileSystemWriter(snake_case_ ) , planner=DefaultSavePlanner() , ) logger.info(F'''Optimizer state saved in {ckpt_dir}''' ) def lowercase__ ( snake_case_ :Optional[int] , snake_case_ :Tuple , snake_case_ :Dict , snake_case_ :Any , snake_case_ :Dict , snake_case_ :List[str]=0 ): accelerator.wait_for_everyone() with FSDP.state_dict_type( snake_case_ , 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 = 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 = ( F'''{OPTIMIZER_NAME}.bin''' if optimizer_index == 0 else F'''{OPTIMIZER_NAME}_{optimizer_index}.bin''' ) __UpperCAmelCase = os.path.join(snake_case_ , snake_case_ ) logger.info(F'''Loading Optimizer state from {input_optimizer_file}''' ) __UpperCAmelCase = torch.load(snake_case_ ) logger.info(F'''Optimizer state loaded from {input_optimizer_file}''' ) else: __UpperCAmelCase = ( os.path.join(snake_case_ , 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 = load_sharded_optimizer_state_dict( model_state_dict=model.state_dict() , optimizer_key='''optimizer''' , storage_reader=dist_cp.FileSystemReader(snake_case_ ) , ) __UpperCAmelCase = optim_state['''optimizer'''] logger.info(F'''Optimizer loaded from {ckpt_dir}''' ) __UpperCAmelCase = FSDP.optim_state_dict_to_load(snake_case_ , snake_case_ , snake_case_ ) optimizer.load_state_dict(snake_case_ )
332
"""simple docstring""" _lowercase : Any = '\n# Installazione di Transformers\n! pip install transformers datasets\n# Per installare dalla fonte invece dell\'ultima versione rilasciata, commenta il comando sopra e\n# rimuovi la modalità commento al comando seguente.\n# ! pip install git+https://github.com/huggingface/transformers.git\n' _lowercase : Tuple = [{'type': 'code', 'content': INSTALL_CONTENT}] _lowercase : int = { '{processor_class}': 'FakeProcessorClass', '{model_class}': 'FakeModelClass', '{object_class}': 'FakeObjectClass', }
332
1
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, ) _lowercase : Any = {'configuration_vit_mae': ['VIT_MAE_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ViTMAEConfig']} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : Optional[int] = [ 'VIT_MAE_PRETRAINED_MODEL_ARCHIVE_LIST', 'ViTMAEForPreTraining', 'ViTMAELayer', 'ViTMAEModel', 'ViTMAEPreTrainedModel', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : Union[str, Any] = [ 'TFViTMAEForPreTraining', 'TFViTMAEModel', 'TFViTMAEPreTrainedModel', ] if TYPE_CHECKING: from .configuration_vit_mae import VIT_MAE_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTMAEConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_vit_mae import ( VIT_MAE_PRETRAINED_MODEL_ARCHIVE_LIST, ViTMAEForPreTraining, ViTMAELayer, ViTMAEModel, ViTMAEPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_vit_mae import TFViTMAEForPreTraining, TFViTMAEModel, TFViTMAEPreTrainedModel else: import sys _lowercase : List[str] = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
332
"""simple docstring""" import importlib.util import os import platform from argparse import ArgumentParser import huggingface_hub from .. import __version__ as version from ..utils import ( is_accelerate_available, is_flax_available, is_safetensors_available, is_tf_available, is_torch_available, ) from . import BaseTransformersCLICommand def lowercase__ ( snake_case_ :Optional[int] ): return EnvironmentCommand() def lowercase__ ( snake_case_ :List[str] ): return EnvironmentCommand(args.accelerate_config_file ) class _UpperCAmelCase ( _lowerCAmelCase ): @staticmethod def a ( _lowercase : ArgumentParser ): __UpperCAmelCase = parser.add_parser('''env''' ) download_parser.set_defaults(func=_lowercase ) download_parser.add_argument( '''--accelerate-config_file''' , default=_lowercase , help='''The accelerate config file to use for the default values in the launching script.''' , ) download_parser.set_defaults(func=_lowercase ) def __init__( self : Optional[int] , _lowercase : str , *_lowercase : Tuple ): __UpperCAmelCase = accelerate_config_file def a ( self : Dict ): __UpperCAmelCase = '''not installed''' if is_safetensors_available(): import safetensors __UpperCAmelCase = safetensors.__version__ elif importlib.util.find_spec('''safetensors''' ) is not None: import safetensors __UpperCAmelCase = F'''{safetensors.__version__} but is ignored because of PyTorch version too old.''' __UpperCAmelCase = '''not installed''' __UpperCAmelCase = __UpperCAmelCase = '''not found''' if is_accelerate_available(): import accelerate from accelerate.commands.config import default_config_file, load_config_from_file __UpperCAmelCase = accelerate.__version__ # Get the default from the config file. if self._accelerate_config_file is not None or os.path.isfile(_lowercase ): __UpperCAmelCase = load_config_from_file(self._accelerate_config_file ).to_dict() __UpperCAmelCase = ( '''\n'''.join([F'''\t- {prop}: {val}''' for prop, val in accelerate_config.items()] ) if isinstance(_lowercase , _lowercase ) else F'''\t{accelerate_config}''' ) __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''NA''' if is_torch_available(): import torch __UpperCAmelCase = torch.__version__ __UpperCAmelCase = torch.cuda.is_available() __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''NA''' if is_tf_available(): import tensorflow as tf __UpperCAmelCase = tf.__version__ try: # deprecated in v2.1 __UpperCAmelCase = tf.test.is_gpu_available() except AttributeError: # returns list of devices, convert to bool __UpperCAmelCase = bool(tf.config.list_physical_devices('''GPU''' ) ) __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''NA''' if is_flax_available(): import flax import jax import jaxlib __UpperCAmelCase = flax.__version__ __UpperCAmelCase = jax.__version__ __UpperCAmelCase = jaxlib.__version__ __UpperCAmelCase = jax.lib.xla_bridge.get_backend().platform __UpperCAmelCase = { '''`transformers` version''': version, '''Platform''': platform.platform(), '''Python version''': platform.python_version(), '''Huggingface_hub version''': huggingface_hub.__version__, '''Safetensors version''': F'''{safetensors_version}''', '''Accelerate version''': F'''{accelerate_version}''', '''Accelerate config''': F'''{accelerate_config_str}''', '''PyTorch version (GPU?)''': F'''{pt_version} ({pt_cuda_available})''', '''Tensorflow version (GPU?)''': F'''{tf_version} ({tf_cuda_available})''', '''Flax version (CPU?/GPU?/TPU?)''': F'''{flax_version} ({jax_backend})''', '''Jax version''': F'''{jax_version}''', '''JaxLib version''': F'''{jaxlib_version}''', '''Using GPU in script?''': '''<fill in>''', '''Using distributed or parallel set-up in script?''': '''<fill in>''', } print('''\nCopy-and-paste the text below in your GitHub issue and FILL OUT the two last points.\n''' ) print(self.format_dict(_lowercase ) ) return info @staticmethod def a ( _lowercase : str ): return "\n".join([F'''- {prop}: {val}''' for prop, val in d.items()] ) + "\n"
332
1
"""simple docstring""" # limitations under the License. from typing import Optional, Tuple, Union import torch from diffusers import DiffusionPipeline, ImagePipelineOutput class _UpperCAmelCase ( _lowerCAmelCase ): def __init__( self : Optional[int] , _lowercase : Any , _lowercase : Optional[Any] ): super().__init__() self.register_modules(unet=_lowercase , scheduler=_lowercase ) @torch.no_grad() def __call__( self : str , _lowercase : int = 1 , _lowercase : Optional[torch.Generator] = None , _lowercase : int = 50 , _lowercase : Optional[str] = "pil" , _lowercase : bool = True , **_lowercase : Union[str, Any] , ): __UpperCAmelCase = torch.randn( (batch_size, self.unet.config.in_channels, self.unet.config.sample_size, self.unet.config.sample_size) , generator=_lowercase , ) __UpperCAmelCase = image.to(self.device ) # set step values self.scheduler.set_timesteps(_lowercase ) for t in self.progress_bar(self.scheduler.timesteps ): # 1. predict noise model_output __UpperCAmelCase = 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 __UpperCAmelCase = self.scheduler.step(_lowercase , _lowercase , _lowercase ).prev_sample __UpperCAmelCase = (image / 2 + 0.5).clamp(0 , 1 ) __UpperCAmelCase = image.cpu().permute(0 , 2 , 3 , 1 ).numpy() if output_type == "pil": __UpperCAmelCase = self.numpy_to_pil(_lowercase ) if not return_dict: return (image,), "This is a local test" return ImagePipelineOutput(images=_lowercase ), "This is a local test"
332
"""simple docstring""" from __future__ import annotations def lowercase__ ( snake_case_ :list[float] , snake_case_ :list[float] ): __UpperCAmelCase = sorted(numsa + numsa ) __UpperCAmelCase , __UpperCAmelCase = divmod(len(snake_case_ ) , 2 ) if mod == 1: return all_numbers[div] else: return (all_numbers[div] + all_numbers[div - 1]) / 2 if __name__ == "__main__": import doctest doctest.testmod() _lowercase : int = [float(x) for x in input('Enter the elements of first array: ').split()] _lowercase : Tuple = [float(x) for x in input('Enter the elements of second array: ').split()] print(f"""The median of two arrays is: {median_of_two_arrays(array_a, array_a)}""")
332
1
"""simple docstring""" import argparse import shutil import time from json import JSONDecodeError from logging import getLogger from pathlib import Path from typing import Dict, List import torch from torch.utils.data import DataLoader from tqdm import tqdm from transformers import AutoModelForSeqaSeqLM, AutoTokenizer from utils import ( SeqaSeqDataset, calculate_bleu, calculate_rouge, chunks, lmap, load_json, parse_numeric_n_bool_cl_kwargs, save_json, use_task_specific_params, write_txt_file, ) _lowercase : List[str] = getLogger(__name__) def lowercase__ ( snake_case_ :List[Any] , snake_case_ :str , snake_case_ :str , snake_case_ :int = 8 , snake_case_ :int = 1_024 , snake_case_ :List[str]="val" , snake_case_ :List[Any]=None , snake_case_ :Tuple=False , snake_case_ :Tuple="summarization" , snake_case_ :List[Any]=None , snake_case_ :List[Any]=1 , snake_case_ :Dict = None , snake_case_ :Any="" , **snake_case_ :Optional[int] , ): __UpperCAmelCase = str(snake_case_ ) assert local_rank is not None torch.distributed.init_process_group(backend='''nccl''' , rank=snake_case_ ) __UpperCAmelCase = Path(snake_case_ ) __UpperCAmelCase = save_dir.joinpath(F'''rank_{local_rank}_output.json''' ) torch.cuda.set_device(snake_case_ ) __UpperCAmelCase = AutoModelForSeqaSeqLM.from_pretrained(snake_case_ ).cuda() if fpaa: __UpperCAmelCase = model.half() # determine if we need to increase num_beams use_task_specific_params(snake_case_ , snake_case_ ) # update config with task specific params __UpperCAmelCase = generate_kwargs.pop('''num_beams''' , model.config.num_beams ) # AttributeError risk? if num_return_sequences > num_beams: __UpperCAmelCase = num_return_sequences __UpperCAmelCase = AutoTokenizer.from_pretrained(snake_case_ ) logger.info(F'''Inferred tokenizer type: {tokenizer.__class__}''' ) # if this is wrong, check config.model_type. if max_source_length is None: __UpperCAmelCase = tokenizer.model_max_length if prefix is None: __UpperCAmelCase = prefix or getattr(model.config , '''prefix''' , '''''' ) or '''''' __UpperCAmelCase = SeqaSeqDataset( snake_case_ , snake_case_ , snake_case_ , max_target_length=1_024 , type_path=snake_case_ , n_obs=snake_case_ , prefix=snake_case_ , **snake_case_ , ) # I set shuffle=True for a more accurate progress bar. # If all the longest samples are first, the prog bar estimate is too high at the beginning. __UpperCAmelCase = ds.make_sortish_sampler(snake_case_ , distributed=snake_case_ , add_extra_examples=snake_case_ , shuffle=snake_case_ ) __UpperCAmelCase = DataLoader(snake_case_ , sampler=snake_case_ , batch_size=snake_case_ , collate_fn=ds.collate_fn ) __UpperCAmelCase = [] for batch in tqdm(snake_case_ ): __UpperCAmelCase = model.generate( input_ids=batch['''input_ids'''].to(model.device ) , attention_mask=batch['''attention_mask'''].to(model.device ) , num_return_sequences=snake_case_ , num_beams=snake_case_ , **snake_case_ , ) __UpperCAmelCase = tokenizer.batch_decode(snake_case_ , skip_special_tokens=snake_case_ , clean_up_tokenization_spaces=snake_case_ ) __UpperCAmelCase = batch['''ids'''] if num_return_sequences > 1: __UpperCAmelCase = chunks(snake_case_ , snake_case_ ) # batch size chunks, each of size num_return_seq for i, pred in enumerate(snake_case_ ): results.append({'''pred''': pred, '''id''': ids[i].item()} ) save_json(snake_case_ , snake_case_ ) return results, sampler.num_replicas def lowercase__ ( ): __UpperCAmelCase = argparse.ArgumentParser( epilog='''Unspecified args like --num_beams=2 --decoder_start_token_id=4 are passed to model.generate''' ) parser.add_argument('''--data_dir''' , type=snake_case_ , help='''like cnn_dm/test.source''' ) parser.add_argument( '''--model_name''' , type=snake_case_ , help='''like facebook/bart-large-cnn,t5-base, etc.''' , default='''sshleifer/distilbart-xsum-12-3''' , ) parser.add_argument('''--save_dir''' , type=snake_case_ , help='''where to save''' , default='''tmp_gen''' ) parser.add_argument('''--max_source_length''' , type=snake_case_ , default=snake_case_ ) parser.add_argument( '''--type_path''' , type=snake_case_ , default='''test''' , help='''which subset to evaluate typically train/val/test''' ) parser.add_argument('''--task''' , type=snake_case_ , default='''summarization''' , help='''used for task_specific_params + metrics''' ) parser.add_argument('''--bs''' , type=snake_case_ , default=8 , required=snake_case_ , help='''batch size''' ) parser.add_argument( '''--local_rank''' , type=snake_case_ , default=-1 , required=snake_case_ , help='''should be passed by distributed.launch''' ) parser.add_argument( '''--n_obs''' , type=snake_case_ , default=snake_case_ , required=snake_case_ , help='''How many observations. Defaults to all.''' ) parser.add_argument( '''--num_return_sequences''' , type=snake_case_ , default=1 , required=snake_case_ , help='''How many sequences to return''' ) parser.add_argument( '''--sync_timeout''' , type=snake_case_ , default=600 , required=snake_case_ , help='''How long should master process wait for other processes to finish.''' , ) parser.add_argument('''--src_lang''' , type=snake_case_ , default=snake_case_ , required=snake_case_ ) parser.add_argument('''--tgt_lang''' , type=snake_case_ , default=snake_case_ , required=snake_case_ ) parser.add_argument( '''--prefix''' , type=snake_case_ , required=snake_case_ , default=snake_case_ , help='''will be added to the begininng of src examples''' ) parser.add_argument('''--fp16''' , action='''store_true''' ) parser.add_argument('''--debug''' , action='''store_true''' ) __UpperCAmelCase = time.time() __UpperCAmelCase , __UpperCAmelCase = parser.parse_known_args() __UpperCAmelCase = parse_numeric_n_bool_cl_kwargs(snake_case_ ) if generate_kwargs and args.local_rank <= 0: print(F'''parsed the following generate kwargs: {generate_kwargs}''' ) __UpperCAmelCase = Path(args.save_dir + '''_tmp''' ) Path(snake_case_ ).mkdir(exist_ok=snake_case_ ) # this handles locking. __UpperCAmelCase = list(json_save_dir.glob('''rank_*.json''' ) ) if intermediate_files: raise ValueError(F'''Found files at {json_save_dir} please move or remove them.''' ) # In theory, a node could finish and save before another node hits this. If this happens, we can address later. __UpperCAmelCase = {} if args.src_lang is not None: __UpperCAmelCase = args.src_lang if args.tgt_lang is not None: __UpperCAmelCase = args.tgt_lang Path(args.save_dir ).mkdir(exist_ok=snake_case_ ) __UpperCAmelCase , __UpperCAmelCase = eval_data_dir( args.data_dir , snake_case_ , args.model_name , type_path=args.type_path , bs=args.bs , fpaa=args.fpaa , task=args.task , local_rank=args.local_rank , n_obs=args.n_obs , max_source_length=args.max_source_length , num_return_sequences=args.num_return_sequences , prefix=args.prefix , dataset_kwargs=snake_case_ , **snake_case_ , ) if args.local_rank <= 0: __UpperCAmelCase = Path(args.save_dir ) save_dir.mkdir(exist_ok=snake_case_ ) __UpperCAmelCase = gather_results_from_each_node(snake_case_ , snake_case_ , args.sync_timeout ) __UpperCAmelCase = combine_partial_results(snake_case_ ) if args.num_return_sequences > 1: __UpperCAmelCase = save_dir.joinpath('''pseudolabel_results.json''' ) print(F'''Saving aggregated results at {save_path}, intermediate in {json_save_dir}/''' ) save_json(snake_case_ , snake_case_ ) return __UpperCAmelCase = Path(args.data_dir ).joinpath(args.type_path + '''.target''' ) with open(snake_case_ ) as f: __UpperCAmelCase = [x.rstrip() for x in f.readlines()][: len(snake_case_ )] # Calculate metrics, save metrics, and save _generations.txt __UpperCAmelCase = '''translation''' in args.task __UpperCAmelCase = calculate_bleu if calc_bleu else calculate_rouge __UpperCAmelCase = '''bleu''' if calc_bleu else '''rouge''' __UpperCAmelCase = score_fn(snake_case_ , snake_case_ ) __UpperCAmelCase = len(snake_case_ ) __UpperCAmelCase = time.time() - start_time __UpperCAmelCase = round(runtime / metrics['''n_obs'''] , 4 ) __UpperCAmelCase = num_replicas # TODO(@stas00): add whatever metadata to metrics __UpperCAmelCase = save_dir.joinpath(F'''{args.type_path}_{metric_name}.json''' ) save_json(snake_case_ , snake_case_ , indent=snake_case_ ) print(snake_case_ ) write_txt_file(snake_case_ , save_dir.joinpath(F'''{args.type_path}_generations.txt''' ) ) if args.debug: write_txt_file(snake_case_ , save_dir.joinpath(F'''{args.type_path}.target''' ) ) else: shutil.rmtree(snake_case_ ) def lowercase__ ( snake_case_ :Dict ): __UpperCAmelCase = [] for partial_result in partial_results: records.extend(snake_case_ ) __UpperCAmelCase = sorted(snake_case_ , key=lambda snake_case_ : x["id"] ) __UpperCAmelCase = [x['''pred'''] for x in records] return preds def lowercase__ ( snake_case_ :str , snake_case_ :List[Any] , snake_case_ :List[str] ): # WAIT FOR lots of .json files __UpperCAmelCase = time.time() logger.info('''waiting for all nodes to finish''' ) __UpperCAmelCase = None while (time.time() - start_wait) < timeout: __UpperCAmelCase = list(save_dir.glob('''rank_*.json''' ) ) if len(snake_case_ ) < num_replicas: continue try: # make sure all json files are fully saved __UpperCAmelCase = lmap(snake_case_ , snake_case_ ) return json_data except JSONDecodeError: continue else: raise TimeoutError('''Rank 0 gave up on waiting for other processes''' ) # Unreachable if __name__ == "__main__": # Usage for MT: run_generate()
332
"""simple docstring""" import heapq as hq import math from collections.abc import Iterator class _UpperCAmelCase : def __init__( self : Union[str, Any] , _lowercase : Optional[Any] ): __UpperCAmelCase = str(id_ ) __UpperCAmelCase = None __UpperCAmelCase = None __UpperCAmelCase = [] __UpperCAmelCase = {} # {vertex:distance} def __lt__( self : str , _lowercase : List[Any] ): return self.key < other.key def __repr__( self : int ): return self.id def a ( self : Union[str, Any] , _lowercase : int ): self.neighbors.append(_lowercase ) def a ( self : List[Any] , _lowercase : Optional[Any] , _lowercase : int ): __UpperCAmelCase = weight def lowercase__ ( snake_case_ :int , snake_case_ :Any , snake_case_ :Union[str, Any] , snake_case_ :List[str] ): # add the neighbors: graph[a - 1].add_neighbor(graph[b - 1] ) graph[b - 1].add_neighbor(graph[a - 1] ) # add the edges: graph[a - 1].add_edge(graph[b - 1] , snake_case_ ) graph[b - 1].add_edge(graph[a - 1] , snake_case_ ) def lowercase__ ( snake_case_ :list , snake_case_ :Vertex ): __UpperCAmelCase = [] for u in graph: __UpperCAmelCase = math.inf __UpperCAmelCase = None __UpperCAmelCase = 0 __UpperCAmelCase = graph[:] while q: __UpperCAmelCase = min(snake_case_ ) q.remove(snake_case_ ) for v in u.neighbors: if (v in q) and (u.edges[v.id] < v.key): __UpperCAmelCase = u __UpperCAmelCase = u.edges[v.id] for i in range(1 , len(snake_case_ ) ): a.append((int(graph[i].id ) + 1, int(graph[i].pi.id ) + 1) ) return a def lowercase__ ( snake_case_ :list , snake_case_ :Vertex ): for u in graph: __UpperCAmelCase = math.inf __UpperCAmelCase = None __UpperCAmelCase = 0 __UpperCAmelCase = list(snake_case_ ) hq.heapify(snake_case_ ) while h: __UpperCAmelCase = hq.heappop(snake_case_ ) for v in u.neighbors: if (v in h) and (u.edges[v.id] < v.key): __UpperCAmelCase = u __UpperCAmelCase = u.edges[v.id] hq.heapify(snake_case_ ) for i in range(1 , len(snake_case_ ) ): yield (int(graph[i].id ) + 1, int(graph[i].pi.id ) + 1) def lowercase__ ( ): pass if __name__ == "__main__": import doctest doctest.testmod()
332
1
"""simple docstring""" from ...configuration_utils import PretrainedConfig from ...utils import logging from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices _lowercase : Union[str, Any] = logging.get_logger(__name__) class _UpperCAmelCase ( _lowerCAmelCase , _lowerCAmelCase ): a__ : str = "maskformer-swin" a__ : Optional[int] = { "num_attention_heads": "num_heads", "num_hidden_layers": "num_layers", } def __init__( self : Union[str, Any] , _lowercase : List[str]=2_24 , _lowercase : List[Any]=4 , _lowercase : Union[str, Any]=3 , _lowercase : Any=96 , _lowercase : Dict=[2, 2, 6, 2] , _lowercase : Any=[3, 6, 12, 24] , _lowercase : Optional[int]=7 , _lowercase : Dict=4.0 , _lowercase : List[Any]=True , _lowercase : Optional[int]=0.0 , _lowercase : Any=0.0 , _lowercase : Dict=0.1 , _lowercase : List[Any]="gelu" , _lowercase : List[str]=False , _lowercase : Tuple=0.02 , _lowercase : Optional[int]=1E-5 , _lowercase : Tuple=None , _lowercase : Optional[Any]=None , **_lowercase : Union[str, Any] , ): super().__init__(**_lowercase ) __UpperCAmelCase = image_size __UpperCAmelCase = patch_size __UpperCAmelCase = num_channels __UpperCAmelCase = embed_dim __UpperCAmelCase = depths __UpperCAmelCase = len(_lowercase ) __UpperCAmelCase = num_heads __UpperCAmelCase = window_size __UpperCAmelCase = mlp_ratio __UpperCAmelCase = qkv_bias __UpperCAmelCase = hidden_dropout_prob __UpperCAmelCase = attention_probs_dropout_prob __UpperCAmelCase = drop_path_rate __UpperCAmelCase = hidden_act __UpperCAmelCase = use_absolute_embeddings __UpperCAmelCase = layer_norm_eps __UpperCAmelCase = initializer_range # 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 __UpperCAmelCase = int(embed_dim * 2 ** (len(_lowercase ) - 1) ) __UpperCAmelCase = ['''stem'''] + [F'''stage{idx}''' for idx in range(1 , len(_lowercase ) + 1 )] __UpperCAmelCase , __UpperCAmelCase = get_aligned_output_features_output_indices( out_features=_lowercase , out_indices=_lowercase , stage_names=self.stage_names )
332
"""simple docstring""" from ...configuration_utils import PretrainedConfig from ...utils import logging _lowercase : str = logging.get_logger(__name__) _lowercase : Dict = { 'microsoft/swinv2-tiny-patch4-window8-256': ( 'https://huggingface.co/microsoft/swinv2-tiny-patch4-window8-256/resolve/main/config.json' ), } class _UpperCAmelCase ( _lowerCAmelCase ): a__ : Tuple = "swinv2" a__ : List[Any] = { "num_attention_heads": "num_heads", "num_hidden_layers": "num_layers", } def __init__( self : Any , _lowercase : List[Any]=2_24 , _lowercase : int=4 , _lowercase : Optional[int]=3 , _lowercase : Optional[Any]=96 , _lowercase : Optional[int]=[2, 2, 6, 2] , _lowercase : Optional[int]=[3, 6, 12, 24] , _lowercase : str=7 , _lowercase : Union[str, Any]=4.0 , _lowercase : List[str]=True , _lowercase : List[Any]=0.0 , _lowercase : Dict=0.0 , _lowercase : List[Any]=0.1 , _lowercase : Union[str, Any]="gelu" , _lowercase : Tuple=False , _lowercase : Optional[int]=0.02 , _lowercase : List[Any]=1E-5 , _lowercase : Tuple=32 , **_lowercase : Optional[int] , ): super().__init__(**_lowercase ) __UpperCAmelCase = image_size __UpperCAmelCase = patch_size __UpperCAmelCase = num_channels __UpperCAmelCase = embed_dim __UpperCAmelCase = depths __UpperCAmelCase = len(_lowercase ) __UpperCAmelCase = num_heads __UpperCAmelCase = window_size __UpperCAmelCase = mlp_ratio __UpperCAmelCase = qkv_bias __UpperCAmelCase = hidden_dropout_prob __UpperCAmelCase = attention_probs_dropout_prob __UpperCAmelCase = drop_path_rate __UpperCAmelCase = hidden_act __UpperCAmelCase = use_absolute_embeddings __UpperCAmelCase = layer_norm_eps __UpperCAmelCase = initializer_range __UpperCAmelCase = encoder_stride # we set the hidden_size attribute in order to make Swinv2 work with VisionEncoderDecoderModel # this indicates the channel dimension after the last stage of the model __UpperCAmelCase = int(embed_dim * 2 ** (len(_lowercase ) - 1) ) __UpperCAmelCase = (0, 0, 0, 0)
332
1
"""simple docstring""" import argparse _lowercase : Optional[Any] = 'docs/source/_static/js/custom.js' def lowercase__ ( snake_case_ :int ): with open(snake_case_ , encoding='''utf-8''' , newline='''\n''' ) as f: __UpperCAmelCase = f.readlines() __UpperCAmelCase = 0 # First let's put the right version while not lines[index].startswith('''const stableVersion =''' ): index += 1 __UpperCAmelCase = F'''const stableVersion = "v{version}"\n''' # Then update the dictionary while not lines[index].startswith('''const versionMapping = {''' ): index += 1 # We go until the end while not lines[index].startswith('''}''' ): index += 1 # We add the new version at the end lines[index - 1] += F''' "v{version}": "v{version}",\n''' with open(snake_case_ , '''w''' , encoding='''utf-8''' , newline='''\n''' ) as f: f.writelines(snake_case_ ) if __name__ == "__main__": _lowercase : Optional[Any] = argparse.ArgumentParser() parser.add_argument('--version', help='Release version.') _lowercase : str = parser.parse_args() update_custom_js(args.version)
332
"""simple docstring""" import pprint import requests _lowercase : Optional[Any] = 'https://zenquotes.io/api' def lowercase__ ( ): return requests.get(API_ENDPOINT_URL + '''/today''' ).json() def lowercase__ ( ): return requests.get(API_ENDPOINT_URL + '''/random''' ).json() if __name__ == "__main__": _lowercase : int = random_quotes() pprint.pprint(response)
332
1
"""simple docstring""" def lowercase__ ( snake_case_ :int , snake_case_ :int ): while second != 0: __UpperCAmelCase = first & second first ^= second __UpperCAmelCase = c << 1 return first if __name__ == "__main__": import doctest doctest.testmod() _lowercase : int = int(input('Enter the first number: ').strip()) _lowercase : Tuple = int(input('Enter the second number: ').strip()) print(f"""{add(first, second) = }""")
332
"""simple docstring""" from typing import List, Optional, Union import numpy as np import tensorflow as tf from .utils import logging _lowercase : List[str] = logging.get_logger(__name__) def lowercase__ ( snake_case_ :Union[tf.Tensor, np.ndarray] ): if isinstance(snake_case_ , np.ndarray ): return list(tensor.shape ) __UpperCAmelCase = tf.shape(snake_case_ ) if tensor.shape == tf.TensorShape(snake_case_ ): return dynamic __UpperCAmelCase = tensor.shape.as_list() return [dynamic[i] if s is None else s for i, s in enumerate(snake_case_ )] def lowercase__ ( snake_case_ :tf.Tensor , snake_case_ :Optional[int] = None , snake_case_ :Optional[str] = None ): return tf.nn.softmax(logits=logits + 1E-9 , axis=snake_case_ , name=snake_case_ ) def lowercase__ ( snake_case_ :int , snake_case_ :Union[str, Any] , snake_case_ :str , snake_case_ :Union[str, Any]=1E-5 , snake_case_ :List[str]=-1 ): # This is a very simplified functional layernorm, designed to duplicate # the functionality of PyTorch nn.functional.layer_norm when this is needed to port # models in Transformers. if weight.shape.rank != 1 or bias.shape.rank != 1 or not isinstance(snake_case_ , snake_case_ ): raise NotImplementedError('''Only 1D weight and bias tensors are supported for now, with only a single axis.''' ) # Get mean and variance on the axis to be normalized __UpperCAmelCase , __UpperCAmelCase = tf.nn.moments(snake_case_ , axes=[axis] , keepdims=snake_case_ ) if axis != -1: # Reshape scale and weight to have the same rank as inputs, but with 1 dimensions # on every dimension except axis __UpperCAmelCase = [1] * inputs.shape.rank __UpperCAmelCase = shape_list(snake_case_ )[axis] __UpperCAmelCase = tf.reshape(snake_case_ , snake_case_ ) __UpperCAmelCase = tf.reshape(snake_case_ , snake_case_ ) # Compute layer normalization using the batch_normalization # function. __UpperCAmelCase = tf.nn.batch_normalization( snake_case_ , snake_case_ , snake_case_ , offset=snake_case_ , scale=snake_case_ , variance_epsilon=snake_case_ , ) return outputs def lowercase__ ( snake_case_ :Optional[int] , snake_case_ :List[str]=0 , snake_case_ :Optional[Any]=-1 ): # Replicates the behavior of torch.flatten in TF # If end_dim or start_dim is negative, count them from the end if end_dim < 0: end_dim += input.shape.rank if start_dim < 0: start_dim += input.shape.rank if start_dim == end_dim: return input __UpperCAmelCase = tf.shape(snake_case_ ) __UpperCAmelCase = tf.math.reduce_prod(in_shape[start_dim : end_dim + 1] ) __UpperCAmelCase = tf.concat([in_shape[:start_dim], [flattened_dim], in_shape[end_dim + 1 :]] , axis=0 ) return tf.reshape(snake_case_ , snake_case_ ) def lowercase__ ( snake_case_ :tf.Tensor ): if not isinstance(snake_case_ , tf.Tensor ): __UpperCAmelCase = tf.convert_to_tensor(snake_case_ ) # Catches stray NumPy inputs if encoder_attention_mask.shape.rank == 3: __UpperCAmelCase = encoder_attention_mask[:, None, :, :] if encoder_attention_mask.shape.rank == 2: __UpperCAmelCase = encoder_attention_mask[:, None, None, :] # T5 has a mask that can compare sequence ids, we can simulate this here with this transposition # Cf. https://github.com/tensorflow/mesh/blob/8d2465e9bc93129b913b5ccc6a59aa97abd96ec6/mesh_tensorflow # /transformer/transformer_layers.py#L270 # encoder_extended_attention_mask = (encoder_extended_attention_mask == # encoder_extended_attention_mask.transpose(-1, -2)) __UpperCAmelCase = ( tf.cast(1 , encoder_attention_mask.dtype ) - encoder_extended_attention_mask ) * encoder_extended_attention_mask.dtype.min return encoder_extended_attention_mask def lowercase__ ( snake_case_ :tf.Tensor , snake_case_ :int , snake_case_ :str = "input_ids" ): tf.debugging.assert_less( snake_case_ , tf.cast(snake_case_ , dtype=tensor.dtype ) , message=( F'''The maximum value of {tensor_name} ({tf.math.reduce_max(snake_case_ )}) must be smaller than the embedding ''' F'''layer\'s input dimension ({embed_dim}). The likely cause is some problem at tokenization time.''' ) , ) def lowercase__ ( snake_case_ :List[Any] , snake_case_ :List[Any] , snake_case_ :List[str] ): __UpperCAmelCase = 64_512 # Check that no item in `data` is larger than `HDF5_OBJECT_HEADER_LIMIT` # because in that case even chunking the array would not make the saving # possible. __UpperCAmelCase = [x for x in data if len(snake_case_ ) > HDF5_OBJECT_HEADER_LIMIT] # Expecting this to never be true. if bad_attributes: raise RuntimeError( '''The following attributes cannot be saved to HDF5 file because ''' F'''they are larger than {HDF5_OBJECT_HEADER_LIMIT} ''' F'''bytes: {bad_attributes}''' ) __UpperCAmelCase = np.asarray(snake_case_ ) __UpperCAmelCase = 1 __UpperCAmelCase = np.array_split(snake_case_ , snake_case_ ) # This will never loop forever thanks to the test above. while any(x.nbytes > HDF5_OBJECT_HEADER_LIMIT for x in chunked_data ): num_chunks += 1 __UpperCAmelCase = np.array_split(snake_case_ , snake_case_ ) if num_chunks > 1: for chunk_id, chunk_data in enumerate(snake_case_ ): __UpperCAmelCase = chunk_data else: __UpperCAmelCase = data def lowercase__ ( snake_case_ :str , snake_case_ :List[str] ): if name in group.attrs: __UpperCAmelCase = [n.decode('''utf8''' ) if hasattr(snake_case_ , '''decode''' ) else n for n in group.attrs[name]] else: __UpperCAmelCase = [] __UpperCAmelCase = 0 while "%s%d" % (name, chunk_id) in group.attrs: data.extend( [n.decode('''utf8''' ) if hasattr(snake_case_ , '''decode''' ) else n for n in group.attrs['''%s%d''' % (name, chunk_id)]] ) chunk_id += 1 return data def lowercase__ ( snake_case_ :Tuple ): def _expand_single_ad_tensor(snake_case_ :Optional[int] ): if isinstance(snake_case_ , tf.Tensor ) and t.shape.rank == 1: return tf.expand_dims(snake_case_ , axis=-1 ) return t return tf.nest.map_structure(_expand_single_ad_tensor , snake_case_ )
332
1
"""simple docstring""" def lowercase__ ( snake_case_ :list , snake_case_ :int = 0 ): __UpperCAmelCase = length or len(snake_case_ ) __UpperCAmelCase = False for i in range(length - 1 ): if list_data[i] > list_data[i + 1]: __UpperCAmelCase , __UpperCAmelCase = list_data[i + 1], list_data[i] __UpperCAmelCase = True return list_data if not swapped else bubble_sort(snake_case_ , length - 1 ) if __name__ == "__main__": import doctest doctest.testmod()
332
"""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 lowercase__ ( snake_case_ :Union[str, Any]=None ): if subparsers is not None: __UpperCAmelCase = subparsers.add_parser('''env''' ) else: __UpperCAmelCase = argparse.ArgumentParser('''Accelerate env command''' ) parser.add_argument( '''--config_file''' , default=snake_case_ , help='''The config file to use for the default values in the launching script.''' ) if subparsers is not None: parser.set_defaults(func=snake_case_ ) return parser def lowercase__ ( snake_case_ :List[Any] ): __UpperCAmelCase = torch.__version__ __UpperCAmelCase = torch.cuda.is_available() __UpperCAmelCase = is_xpu_available() __UpperCAmelCase = is_npu_available() __UpperCAmelCase = '''Not found''' # Get the default from the config file. if args.config_file is not None or os.path.isfile(snake_case_ ): __UpperCAmelCase = load_config_from_file(args.config_file ).to_dict() __UpperCAmelCase = { '''`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(snake_case_ ), '''PyTorch NPU available''': str(snake_case_ ), '''System RAM''': F'''{psutil.virtual_memory().total / 1_024 ** 3:.2f} GB''', } if pt_cuda_available: __UpperCAmelCase = 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 = ( '''\n'''.join([F'''\t- {prop}: {val}''' for prop, val in accelerate_config.items()] ) if isinstance(snake_case_ , snake_case_ ) else F'''\t{accelerate_config}''' ) print(snake_case_ ) __UpperCAmelCase = accelerate_config return info def lowercase__ ( ): __UpperCAmelCase = env_command_parser() __UpperCAmelCase = parser.parse_args() env_command(snake_case_ ) return 0 if __name__ == "__main__": raise SystemExit(main())
332
1
"""simple docstring""" from typing import List from .keymap import KEYMAP, get_character def lowercase__ ( snake_case_ :str ): def decorator(snake_case_ :List[Any] ): __UpperCAmelCase = getattr(snake_case_ , '''handle_key''' , [] ) handle += [key] setattr(snake_case_ , '''handle_key''' , snake_case_ ) return func return decorator def lowercase__ ( *snake_case_ :List[str] ): def decorator(snake_case_ :Optional[Any] ): __UpperCAmelCase = getattr(snake_case_ , '''handle_key''' , [] ) handle += keys setattr(snake_case_ , '''handle_key''' , snake_case_ ) return func return decorator class _UpperCAmelCase ( _lowerCAmelCase ): def __new__( cls : Union[str, Any] , _lowercase : List[str] , _lowercase : str , _lowercase : Optional[int] ): __UpperCAmelCase = super().__new__(cls , _lowercase , _lowercase , _lowercase ) if not hasattr(_lowercase , '''key_handler''' ): setattr(_lowercase , '''key_handler''' , {} ) setattr(_lowercase , '''handle_input''' , KeyHandler.handle_input ) for value in attrs.values(): __UpperCAmelCase = getattr(_lowercase , '''handle_key''' , [] ) for key in handled_keys: __UpperCAmelCase = value return new_cls @staticmethod def a ( cls : Dict ): __UpperCAmelCase = get_character() if char != KEYMAP["undefined"]: __UpperCAmelCase = ord(_lowercase ) __UpperCAmelCase = cls.key_handler.get(_lowercase ) if handler: __UpperCAmelCase = char return handler(cls ) else: return None def lowercase__ ( cls :Union[str, Any] ): return KeyHandler(cls.__name__ , cls.__bases__ , cls.__dict__.copy() )
332
"""simple docstring""" import shutil import tempfile import unittest from transformers import SPIECE_UNDERLINE, BatchEncoding, MBartaaTokenizer, MBartaaTokenizerFast, is_torch_available from transformers.testing_utils import ( get_tests_dir, nested_simplify, require_sentencepiece, require_tokenizers, require_torch, slow, ) from ...test_tokenization_common import TokenizerTesterMixin _lowercase : Tuple = get_tests_dir('fixtures/test_sentencepiece.model') if is_torch_available(): from transformers.models.mbart.modeling_mbart import shift_tokens_right _lowercase : List[str] = 25_00_04 _lowercase : int = 25_00_20 @require_sentencepiece @require_tokenizers class _UpperCAmelCase ( _lowerCAmelCase , unittest.TestCase ): a__ : Union[str, Any] = MBartaaTokenizer a__ : List[str] = MBartaaTokenizerFast a__ : Any = True a__ : List[str] = True def a ( self : str ): super().setUp() # We have a SentencePiece fixture for testing __UpperCAmelCase = MBartaaTokenizer(_lowercase , src_lang='''en_XX''' , tgt_lang='''ro_RO''' , keep_accents=_lowercase ) tokenizer.save_pretrained(self.tmpdirname ) def a ( self : Dict ): __UpperCAmelCase = '''<s>''' __UpperCAmelCase = 0 self.assertEqual(self.get_tokenizer()._convert_token_to_id(_lowercase ) , _lowercase ) self.assertEqual(self.get_tokenizer()._convert_id_to_token(_lowercase ) , _lowercase ) def a ( self : Optional[Any] ): __UpperCAmelCase = list(self.get_tokenizer().get_vocab().keys() ) self.assertEqual(vocab_keys[0] , '''<s>''' ) self.assertEqual(vocab_keys[1] , '''<pad>''' ) self.assertEqual(vocab_keys[-1] , '''<mask>''' ) self.assertEqual(len(_lowercase ) , 10_54 ) def a ( self : Tuple ): self.assertEqual(self.get_tokenizer().vocab_size , 10_54 ) def a ( self : str ): __UpperCAmelCase = MBartaaTokenizer(_lowercase , src_lang='''en_XX''' , tgt_lang='''ro_RO''' , keep_accents=_lowercase ) __UpperCAmelCase = tokenizer.tokenize('''This is a test''' ) self.assertListEqual(_lowercase , ['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est'''] ) self.assertListEqual( tokenizer.convert_tokens_to_ids(_lowercase ) , [value + tokenizer.fairseq_offset for value in [2_85, 46, 10, 1_70, 3_82]] , ) __UpperCAmelCase = tokenizer.tokenize('''I was born in 92000, and this is falsé.''' ) self.assertListEqual( _lowercase , [SPIECE_UNDERLINE + '''I''', SPIECE_UNDERLINE + '''was''', SPIECE_UNDERLINE + '''b''', '''or''', '''n''', SPIECE_UNDERLINE + '''in''', SPIECE_UNDERLINE + '''''', '''9''', '''2''', '''0''', '''0''', '''0''', ''',''', SPIECE_UNDERLINE + '''and''', SPIECE_UNDERLINE + '''this''', SPIECE_UNDERLINE + '''is''', SPIECE_UNDERLINE + '''f''', '''al''', '''s''', '''é''', '''.'''] , ) __UpperCAmelCase = tokenizer.convert_tokens_to_ids(_lowercase ) self.assertListEqual( _lowercase , [ value + tokenizer.fairseq_offset for value in [8, 21, 84, 55, 24, 19, 7, 2, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 2, 4] ] , ) __UpperCAmelCase = tokenizer.convert_ids_to_tokens(_lowercase ) self.assertListEqual( _lowercase , [SPIECE_UNDERLINE + '''I''', SPIECE_UNDERLINE + '''was''', SPIECE_UNDERLINE + '''b''', '''or''', '''n''', SPIECE_UNDERLINE + '''in''', SPIECE_UNDERLINE + '''''', '''<unk>''', '''2''', '''0''', '''0''', '''0''', ''',''', SPIECE_UNDERLINE + '''and''', SPIECE_UNDERLINE + '''this''', SPIECE_UNDERLINE + '''is''', SPIECE_UNDERLINE + '''f''', '''al''', '''s''', '''<unk>''', '''.'''] , ) @slow def a ( self : str ): # fmt: off __UpperCAmelCase = {'''input_ids''': [[25_00_04, 1_10_62, 8_27_72, 7, 15, 8_27_72, 5_38, 5_15_29, 2_37, 1_71_98, 12_90, 2_06, 9, 21_51_75, 13_14, 1_36, 1_71_98, 12_90, 2_06, 9, 5_63_59, 42, 12_20_09, 9, 1_64_66, 16, 8_73_44, 45_37, 9, 47_17, 7_83_81, 6, 15_99_58, 7, 15, 2_44_80, 6_18, 4, 5_27, 2_26_93, 54_28, 4, 27_77, 2_44_80, 98_74, 4, 4_35_23, 5_94, 4, 8_03, 1_83_92, 3_31_89, 18, 4, 4_35_23, 2_44_47, 1_23_99, 1_00, 2_49_55, 8_36_58, 96_26, 14_40_57, 15, 8_39, 2_23_35, 16, 1_36, 2_49_55, 8_36_58, 8_34_79, 15, 3_91_02, 7_24, 16, 6_78, 6_45, 27_89, 13_28, 45_89, 42, 12_20_09, 11_57_74, 23, 8_05, 13_28, 4_68_76, 7, 1_36, 5_38_94, 19_40, 4_22_27, 4_11_59, 1_77_21, 8_23, 4_25, 4, 2_75_12, 9_87_22, 2_06, 1_36, 55_31, 49_70, 9_19, 1_73_36, 5, 2], [25_00_04, 2_00_80, 6_18, 83, 8_27_75, 47, 4_79, 9, 15_17, 73, 5_38_94, 3_33, 8_05_81, 11_01_17, 1_88_11, 52_56, 12_95, 51, 15_25_26, 2_97, 79_86, 3_90, 12_44_16, 5_38, 3_54_31, 2_14, 98, 1_50_44, 2_57_37, 1_36, 71_08, 4_37_01, 23, 7_56, 13_53_55, 7, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [25_00_04, 5_81, 6_37_73, 11_94_55, 6, 14_77_97, 8_82_03, 7, 6_45, 70, 21, 32_85, 1_02_69, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], '''attention_mask''': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]} # noqa: E501 # fmt: on self.tokenizer_integration_test_util( expected_encoding=_lowercase , model_name='''facebook/mbart-large-50''' , revision='''d3913889c59cd5c9e456b269c376325eabad57e2''' , ) def a ( self : 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 __UpperCAmelCase = (self.rust_tokenizer_class, '''hf-internal-testing/tiny-random-mbart50''', {}) for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})''' ): __UpperCAmelCase = self.rust_tokenizer_class.from_pretrained(_lowercase , **_lowercase ) __UpperCAmelCase = self.tokenizer_class.from_pretrained(_lowercase , **_lowercase ) __UpperCAmelCase = tempfile.mkdtemp() __UpperCAmelCase = tokenizer_r.save_pretrained(_lowercase ) __UpperCAmelCase = tokenizer_p.save_pretrained(_lowercase ) # Checks it save with the same files + the tokenizer.json file for the fast one self.assertTrue(any('''tokenizer.json''' in f for f in tokenizer_r_files ) ) __UpperCAmelCase = tuple(f for f in tokenizer_r_files if '''tokenizer.json''' not in f ) self.assertSequenceEqual(_lowercase , _lowercase ) # Checks everything loads correctly in the same way __UpperCAmelCase = tokenizer_r.from_pretrained(_lowercase ) __UpperCAmelCase = tokenizer_p.from_pretrained(_lowercase ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(_lowercase , _lowercase ) ) # self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key)) # self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id")) shutil.rmtree(_lowercase ) # Save tokenizer rust, legacy_format=True __UpperCAmelCase = tempfile.mkdtemp() __UpperCAmelCase = tokenizer_r.save_pretrained(_lowercase , legacy_format=_lowercase ) __UpperCAmelCase = tokenizer_p.save_pretrained(_lowercase ) # Checks it save with the same files self.assertSequenceEqual(_lowercase , _lowercase ) # Checks everything loads correctly in the same way __UpperCAmelCase = tokenizer_r.from_pretrained(_lowercase ) __UpperCAmelCase = tokenizer_p.from_pretrained(_lowercase ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(_lowercase , _lowercase ) ) shutil.rmtree(_lowercase ) # Save tokenizer rust, legacy_format=False __UpperCAmelCase = tempfile.mkdtemp() __UpperCAmelCase = tokenizer_r.save_pretrained(_lowercase , legacy_format=_lowercase ) __UpperCAmelCase = tokenizer_p.save_pretrained(_lowercase ) # Checks it saved the tokenizer.json file self.assertTrue(any('''tokenizer.json''' in f for f in tokenizer_r_files ) ) # Checks everything loads correctly in the same way __UpperCAmelCase = tokenizer_r.from_pretrained(_lowercase ) __UpperCAmelCase = tokenizer_p.from_pretrained(_lowercase ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(_lowercase , _lowercase ) ) shutil.rmtree(_lowercase ) @require_torch @require_sentencepiece @require_tokenizers class _UpperCAmelCase ( unittest.TestCase ): a__ : str = "facebook/mbart-large-50-one-to-many-mmt" a__ : Union[str, Any] = [ " UN Chief Says There Is No Military Solution in Syria", " Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.", ] a__ : Any = [ "Şeful ONU declară că nu există o soluţie militară în Siria", "Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei" " pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor" " face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.", ] a__ : Any = [EN_CODE, 8_274, 127_873, 25_916, 7, 8_622, 2_071, 438, 67_485, 53, 187_895, 23, 51_712, 2] @classmethod def a ( cls : Tuple ): __UpperCAmelCase = MBartaaTokenizer.from_pretrained( cls.checkpoint_name , src_lang='''en_XX''' , tgt_lang='''ro_RO''' ) __UpperCAmelCase = 1 return cls def a ( self : Union[str, Any] ): self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ar_AR'''] , 25_00_01 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''en_EN'''] , 25_00_04 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ro_RO'''] , 25_00_20 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''mr_IN'''] , 25_00_38 ) def a ( self : Union[str, Any] ): __UpperCAmelCase = self.tokenizer.batch_encode_plus(self.src_text ).input_ids[0] self.assertListEqual(self.expected_src_tokens , _lowercase ) def a ( self : Optional[Any] ): self.assertIn(_lowercase , self.tokenizer.all_special_ids ) __UpperCAmelCase = [RO_CODE, 8_84, 90_19, 96, 9, 9_16, 8_67_92, 36, 1_87_43, 1_55_96, 5, 2] __UpperCAmelCase = self.tokenizer.decode(_lowercase , skip_special_tokens=_lowercase ) __UpperCAmelCase = self.tokenizer.decode(generated_ids[1:] , skip_special_tokens=_lowercase ) self.assertEqual(_lowercase , _lowercase ) self.assertNotIn(self.tokenizer.eos_token , _lowercase ) def a ( self : Optional[Any] ): __UpperCAmelCase = ['''this is gunna be a long sentence ''' * 20] assert isinstance(src_text[0] , _lowercase ) __UpperCAmelCase = 10 __UpperCAmelCase = self.tokenizer(_lowercase , max_length=_lowercase , truncation=_lowercase ).input_ids[0] self.assertEqual(ids[0] , _lowercase ) self.assertEqual(ids[-1] , 2 ) self.assertEqual(len(_lowercase ) , _lowercase ) def a ( self : Optional[int] ): self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['''<mask>''', '''ar_AR'''] ) , [25_00_53, 25_00_01] ) def a ( self : Union[str, Any] ): __UpperCAmelCase = tempfile.mkdtemp() __UpperCAmelCase = self.tokenizer.fairseq_tokens_to_ids self.tokenizer.save_pretrained(_lowercase ) __UpperCAmelCase = MBartaaTokenizer.from_pretrained(_lowercase ) self.assertDictEqual(new_tok.fairseq_tokens_to_ids , _lowercase ) @require_torch def a ( self : Dict ): __UpperCAmelCase = self.tokenizer(self.src_text , text_target=self.tgt_text , padding=_lowercase , return_tensors='''pt''' ) __UpperCAmelCase = shift_tokens_right(batch['''labels'''] , self.tokenizer.pad_token_id ) # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4 assert batch.input_ids[1][0] == EN_CODE assert batch.input_ids[1][-1] == 2 assert batch.labels[1][0] == RO_CODE assert batch.labels[1][-1] == 2 assert batch.decoder_input_ids[1][:2].tolist() == [2, RO_CODE] @require_torch def a ( self : Union[str, Any] ): __UpperCAmelCase = self.tokenizer( self.src_text , text_target=self.tgt_text , padding=_lowercase , truncation=_lowercase , max_length=len(self.expected_src_tokens ) , return_tensors='''pt''' , ) __UpperCAmelCase = shift_tokens_right(batch['''labels'''] , self.tokenizer.pad_token_id ) self.assertIsInstance(_lowercase , _lowercase ) self.assertEqual((2, 14) , batch.input_ids.shape ) self.assertEqual((2, 14) , batch.attention_mask.shape ) __UpperCAmelCase = batch.input_ids.tolist()[0] self.assertListEqual(self.expected_src_tokens , _lowercase ) self.assertEqual(2 , batch.decoder_input_ids[0, 0] ) # decoder_start_token_id # Test that special tokens are reset self.assertEqual(self.tokenizer.prefix_tokens , [EN_CODE] ) self.assertEqual(self.tokenizer.suffix_tokens , [self.tokenizer.eos_token_id] ) def a ( self : Union[str, Any] ): __UpperCAmelCase = self.tokenizer(self.src_text , padding=_lowercase , truncation=_lowercase , max_length=3 , return_tensors='''pt''' ) __UpperCAmelCase = self.tokenizer( text_target=self.tgt_text , padding=_lowercase , truncation=_lowercase , max_length=10 , return_tensors='''pt''' ) __UpperCAmelCase = targets['''input_ids'''] __UpperCAmelCase = shift_tokens_right(_lowercase , self.tokenizer.pad_token_id ) self.assertEqual(batch.input_ids.shape[1] , 3 ) self.assertEqual(batch.decoder_input_ids.shape[1] , 10 ) @require_torch def a ( self : Dict ): __UpperCAmelCase = self.tokenizer._build_translation_inputs( '''A test''' , return_tensors='''pt''' , src_lang='''en_XX''' , tgt_lang='''ar_AR''' ) self.assertEqual( nested_simplify(_lowercase ) , { # en_XX, A, test, EOS '''input_ids''': [[25_00_04, 62, 30_34, 2]], '''attention_mask''': [[1, 1, 1, 1]], # ar_AR '''forced_bos_token_id''': 25_00_01, } , )
332
1
"""simple docstring""" from __future__ import annotations import time import numpy as np _lowercase : List[Any] = [8, 5, 9, 7] _lowercase : List[str] = [ [2, 0, 1, 1], [0, 1, 2, 1], [4, 0, 0, 3], [0, 2, 1, 0], [1, 0, 3, 0], ] _lowercase : Dict = [ [3, 2, 1, 4], [0, 2, 5, 2], [5, 1, 0, 5], [1, 5, 3, 0], [3, 0, 3, 3], ] class _UpperCAmelCase : def __init__( self : Tuple , _lowercase : list[int] , _lowercase : list[list[int]] , _lowercase : list[list[int]] , ): __UpperCAmelCase = claim_vector __UpperCAmelCase = allocated_resources_table __UpperCAmelCase = maximum_claim_table def a ( self : List[str] ): return [ sum(p_item[i] for p_item in self.__allocated_resources_table ) for i in range(len(self.__allocated_resources_table[0] ) ) ] def a ( self : Tuple ): return np.array(self.__claim_vector ) - np.array( self.__processes_resource_summation() ) def a ( self : Tuple ): return [ list(np.array(self.__maximum_claim_table[i] ) - np.array(_lowercase ) ) for i, allocated_resource in enumerate(self.__allocated_resources_table ) ] def a ( self : List[str] ): return {self.__need().index(_lowercase ): i for i in self.__need()} def a ( self : List[Any] , **_lowercase : str ): __UpperCAmelCase = self.__need() __UpperCAmelCase = self.__allocated_resources_table __UpperCAmelCase = self.__available_resources() __UpperCAmelCase = self.__need_index_manager() for kw, val in kwargs.items(): if kw and val is True: self.__pretty_data() print('''_''' * 50 + '''\n''' ) while need_list: __UpperCAmelCase = False for each_need in need_list: __UpperCAmelCase = True for index, need in enumerate(_lowercase ): if need > available_resources[index]: __UpperCAmelCase = False break if execution: __UpperCAmelCase = True # get the original index of the process from ind_ctrl db for original_need_index, need_clone in need_index_manager.items(): if each_need == need_clone: __UpperCAmelCase = original_need_index print(F'''Process {process_number + 1} is executing.''' ) # remove the process run from stack need_list.remove(_lowercase ) # update available/freed resources stack __UpperCAmelCase = np.array(_lowercase ) + np.array( alloc_resources_table[process_number] ) print( '''Updated available resource stack for processes: ''' + ''' '''.join([str(_lowercase ) for x in available_resources] ) ) break if safe: print('''The process is in a safe state.\n''' ) else: print('''System in unsafe state. Aborting...\n''' ) break def a ( self : str ): print(''' ''' * 9 + '''Allocated Resource Table''' ) for item in self.__allocated_resources_table: print( F'''P{self.__allocated_resources_table.index(_lowercase ) + 1}''' + ''' '''.join(F'''{it:>8}''' for it in item ) + '''\n''' ) print(''' ''' * 9 + '''System Resource Table''' ) for item in self.__maximum_claim_table: print( F'''P{self.__maximum_claim_table.index(_lowercase ) + 1}''' + ''' '''.join(F'''{it:>8}''' for it in item ) + '''\n''' ) print( '''Current Usage by Active Processes: ''' + ''' '''.join(str(_lowercase ) for x in self.__claim_vector ) ) print( '''Initial Available Resources: ''' + ''' '''.join(str(_lowercase ) for x in self.__available_resources() ) ) time.sleep(1 ) if __name__ == "__main__": import doctest doctest.testmod()
332
"""simple docstring""" import unittest import torch from torch import nn from accelerate.test_utils import require_cuda from accelerate.utils.memory import find_executable_batch_size, release_memory def lowercase__ ( ): raise RuntimeError('''CUDA out of memory.''' ) class _UpperCAmelCase ( nn.Module ): def __init__( self : Optional[Any] ): super().__init__() __UpperCAmelCase = nn.Linear(3 , 4 ) __UpperCAmelCase = nn.BatchNormad(4 ) __UpperCAmelCase = nn.Linear(4 , 5 ) def a ( self : Optional[int] , _lowercase : Optional[Any] ): return self.lineara(self.batchnorm(self.lineara(_lowercase ) ) ) class _UpperCAmelCase ( unittest.TestCase ): def a ( self : List[str] ): __UpperCAmelCase = [] @find_executable_batch_size(starting_batch_size=1_28 ) def mock_training_loop_function(_lowercase : Optional[int] ): nonlocal batch_sizes batch_sizes.append(_lowercase ) if batch_size != 8: raise_fake_out_of_memory() mock_training_loop_function() self.assertListEqual(_lowercase , [1_28, 64, 32, 16, 8] ) def a ( self : Optional[int] ): __UpperCAmelCase = [] @find_executable_batch_size(starting_batch_size=1_28 ) def mock_training_loop_function(_lowercase : str , _lowercase : List[str] ): nonlocal batch_sizes batch_sizes.append(_lowercase ) if batch_size != 8: raise_fake_out_of_memory() return batch_size, arga __UpperCAmelCase , __UpperCAmelCase = mock_training_loop_function('''hello''' ) self.assertListEqual(_lowercase , [1_28, 64, 32, 16, 8] ) self.assertListEqual([bs, arga] , [8, '''hello'''] ) def a ( self : Tuple ): @find_executable_batch_size(starting_batch_size=0 ) def mock_training_loop_function(_lowercase : Optional[int] ): pass with self.assertRaises(_lowercase ) as cm: mock_training_loop_function() self.assertIn('''No executable batch size found, reached zero.''' , cm.exception.args[0] ) def a ( self : List[Any] ): @find_executable_batch_size(starting_batch_size=16 ) def mock_training_loop_function(_lowercase : List[Any] ): if batch_size > 0: raise_fake_out_of_memory() pass with self.assertRaises(_lowercase ) as cm: mock_training_loop_function() self.assertIn('''No executable batch size found, reached zero.''' , cm.exception.args[0] ) def a ( self : Union[str, Any] ): @find_executable_batch_size(starting_batch_size=1_28 ) def mock_training_loop_function(_lowercase : Optional[Any] , _lowercase : List[str] , _lowercase : str ): if batch_size != 8: raise raise_fake_out_of_memory() with self.assertRaises(_lowercase ) as cm: mock_training_loop_function(1_28 , '''hello''' , '''world''' ) self.assertIn('''Batch size was passed into `f`''' , cm.exception.args[0] ) self.assertIn('''`f(arg1=\'hello\', arg2=\'world\')''' , cm.exception.args[0] ) def a ( self : Dict ): @find_executable_batch_size(starting_batch_size=16 ) def mock_training_loop_function(_lowercase : int ): raise ValueError('''Oops, we had an error!''' ) with self.assertRaises(_lowercase ) as cm: mock_training_loop_function() self.assertIn('''Oops, we had an error!''' , cm.exception.args[0] ) @require_cuda def a ( self : str ): __UpperCAmelCase = torch.cuda.memory_allocated() __UpperCAmelCase = ModelForTest() model.cuda() self.assertGreater(torch.cuda.memory_allocated() , _lowercase ) __UpperCAmelCase = release_memory(_lowercase ) self.assertEqual(torch.cuda.memory_allocated() , _lowercase )
332
1
"""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 _lowercase : Union[str, Any] = logging.get_logger(__name__) _lowercase : Dict = { 'facebook/data2vec-vision-base-ft': ( 'https://huggingface.co/facebook/data2vec-vision-base-ft/resolve/main/config.json' ), } class _UpperCAmelCase ( _lowerCAmelCase ): a__ : Union[str, Any] = "data2vec-vision" def __init__( self : Optional[int] , _lowercase : Optional[int]=7_68 , _lowercase : Tuple=12 , _lowercase : str=12 , _lowercase : str=30_72 , _lowercase : str="gelu" , _lowercase : List[str]=0.0 , _lowercase : str=0.0 , _lowercase : Tuple=0.02 , _lowercase : Optional[Any]=1E-12 , _lowercase : List[Any]=2_24 , _lowercase : Dict=16 , _lowercase : int=3 , _lowercase : Union[str, Any]=False , _lowercase : Optional[int]=False , _lowercase : Tuple=False , _lowercase : Optional[Any]=False , _lowercase : Optional[Any]=0.1 , _lowercase : Dict=0.1 , _lowercase : List[str]=True , _lowercase : Tuple=[3, 5, 7, 11] , _lowercase : List[Any]=[1, 2, 3, 6] , _lowercase : Tuple=True , _lowercase : Tuple=0.4 , _lowercase : Optional[Any]=2_56 , _lowercase : str=1 , _lowercase : Optional[Any]=False , _lowercase : Union[str, Any]=2_55 , **_lowercase : Optional[Any] , ): super().__init__(**_lowercase ) __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 = initializer_range __UpperCAmelCase = layer_norm_eps __UpperCAmelCase = image_size __UpperCAmelCase = patch_size __UpperCAmelCase = num_channels __UpperCAmelCase = use_mask_token __UpperCAmelCase = use_absolute_position_embeddings __UpperCAmelCase = use_relative_position_bias __UpperCAmelCase = use_shared_relative_position_bias __UpperCAmelCase = layer_scale_init_value __UpperCAmelCase = drop_path_rate __UpperCAmelCase = use_mean_pooling # decode head attributes (semantic segmentation) __UpperCAmelCase = out_indices __UpperCAmelCase = pool_scales # auxiliary head attributes (semantic segmentation) __UpperCAmelCase = use_auxiliary_head __UpperCAmelCase = auxiliary_loss_weight __UpperCAmelCase = auxiliary_channels __UpperCAmelCase = auxiliary_num_convs __UpperCAmelCase = auxiliary_concat_input __UpperCAmelCase = semantic_loss_ignore_index class _UpperCAmelCase ( _lowerCAmelCase ): a__ : int = version.parse("1.11" ) @property def a ( self : Union[str, Any] ): return OrderedDict( [ ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}), ] ) @property def a ( self : Dict ): return 1E-4
332
"""simple docstring""" import argparse import copy def lowercase__ ( snake_case_ :Tuple ): __UpperCAmelCase = {} with open(snake_case_ ) as f: for line in f: if line.split()[0] not in dict_of_neighbours: __UpperCAmelCase = [] _list.append([line.split()[1], line.split()[2]] ) __UpperCAmelCase = _list else: dict_of_neighbours[line.split()[0]].append( [line.split()[1], line.split()[2]] ) if line.split()[1] not in dict_of_neighbours: __UpperCAmelCase = [] _list.append([line.split()[0], line.split()[2]] ) __UpperCAmelCase = _list else: dict_of_neighbours[line.split()[1]].append( [line.split()[0], line.split()[2]] ) return dict_of_neighbours def lowercase__ ( snake_case_ :Dict , snake_case_ :Optional[Any] ): with open(snake_case_ ) as f: __UpperCAmelCase = f.read(1 ) __UpperCAmelCase = start_node __UpperCAmelCase = [] __UpperCAmelCase = start_node __UpperCAmelCase = 0 while visiting not in first_solution: __UpperCAmelCase = 10_000 for k in dict_of_neighbours[visiting]: if int(k[1] ) < int(snake_case_ ) and k[0] not in first_solution: __UpperCAmelCase = k[1] __UpperCAmelCase = k[0] first_solution.append(snake_case_ ) __UpperCAmelCase = distance_of_first_solution + int(snake_case_ ) __UpperCAmelCase = best_node first_solution.append(snake_case_ ) __UpperCAmelCase = 0 for k in dict_of_neighbours[first_solution[-2]]: if k[0] == start_node: break position += 1 __UpperCAmelCase = ( distance_of_first_solution + int(dict_of_neighbours[first_solution[-2]][position][1] ) - 10_000 ) return first_solution, distance_of_first_solution def lowercase__ ( snake_case_ :int , snake_case_ :Tuple ): __UpperCAmelCase = [] for n in solution[1:-1]: __UpperCAmelCase = solution.index(snake_case_ ) for kn in solution[1:-1]: __UpperCAmelCase = solution.index(snake_case_ ) if n == kn: continue __UpperCAmelCase = copy.deepcopy(snake_case_ ) __UpperCAmelCase = kn __UpperCAmelCase = n __UpperCAmelCase = 0 for k in _tmp[:-1]: __UpperCAmelCase = _tmp[_tmp.index(snake_case_ ) + 1] for i in dict_of_neighbours[k]: if i[0] == next_node: __UpperCAmelCase = distance + int(i[1] ) _tmp.append(snake_case_ ) if _tmp not in neighborhood_of_solution: neighborhood_of_solution.append(_tmp ) __UpperCAmelCase = len(neighborhood_of_solution[0] ) - 1 neighborhood_of_solution.sort(key=lambda snake_case_ : x[index_of_last_item_in_the_list] ) return neighborhood_of_solution def lowercase__ ( snake_case_ :str , snake_case_ :Union[str, Any] , snake_case_ :Optional[int] , snake_case_ :Dict , snake_case_ :int ): __UpperCAmelCase = 1 __UpperCAmelCase = first_solution __UpperCAmelCase = [] __UpperCAmelCase = distance_of_first_solution __UpperCAmelCase = solution while count <= iters: __UpperCAmelCase = find_neighborhood(snake_case_ , snake_case_ ) __UpperCAmelCase = 0 __UpperCAmelCase = neighborhood[index_of_best_solution] __UpperCAmelCase = len(snake_case_ ) - 1 __UpperCAmelCase = False while not found: __UpperCAmelCase = 0 while i < len(snake_case_ ): if best_solution[i] != solution[i]: __UpperCAmelCase = best_solution[i] __UpperCAmelCase = solution[i] break __UpperCAmelCase = i + 1 if [first_exchange_node, second_exchange_node] not in tabu_list and [ second_exchange_node, first_exchange_node, ] not in tabu_list: tabu_list.append([first_exchange_node, second_exchange_node] ) __UpperCAmelCase = True __UpperCAmelCase = best_solution[:-1] __UpperCAmelCase = neighborhood[index_of_best_solution][best_cost_index] if cost < best_cost: __UpperCAmelCase = cost __UpperCAmelCase = solution else: __UpperCAmelCase = index_of_best_solution + 1 __UpperCAmelCase = neighborhood[index_of_best_solution] if len(snake_case_ ) >= size: tabu_list.pop(0 ) __UpperCAmelCase = count + 1 return best_solution_ever, best_cost def lowercase__ ( snake_case_ :str=None ): __UpperCAmelCase = generate_neighbours(args.File ) __UpperCAmelCase , __UpperCAmelCase = generate_first_solution( args.File , snake_case_ ) __UpperCAmelCase , __UpperCAmelCase = tabu_search( snake_case_ , snake_case_ , snake_case_ , args.Iterations , args.Size , ) print(F'''Best solution: {best_sol}, with total distance: {best_cost}.''' ) if __name__ == "__main__": _lowercase : List[str] = argparse.ArgumentParser(description='Tabu Search') parser.add_argument( '-f', '--File', type=str, help='Path to the file containing the data', required=True, ) parser.add_argument( '-i', '--Iterations', type=int, help='How many iterations the algorithm should perform', required=True, ) parser.add_argument( '-s', '--Size', type=int, help='Size of the tabu list', required=True ) # Pass the arguments to main method main(parser.parse_args())
332
1
"""simple docstring""" def lowercase__ ( snake_case_ :int = 10 , snake_case_ :int = 1_000 , snake_case_ :bool = True ): assert ( isinstance(snake_case_ , snake_case_ ) and isinstance(snake_case_ , snake_case_ ) and isinstance(snake_case_ , snake_case_ ) ), "Invalid type of value(s) specified to function!" if min_val > max_val: raise ValueError('''Invalid value for min_val or max_val (min_value < max_value)''' ) return min_val if option else max_val def lowercase__ ( snake_case_ :int , snake_case_ :int ): return int((number_a + number_a) / 2 ) def lowercase__ ( snake_case_ :int , snake_case_ :int , snake_case_ :int ): assert ( isinstance(snake_case_ , snake_case_ ) and isinstance(snake_case_ , snake_case_ ) and isinstance(snake_case_ , snake_case_ ) ), 'argument values must be type of "int"' if lower > higher: raise ValueError('''argument value for lower and higher must be(lower > higher)''' ) if not lower < to_guess < higher: raise ValueError( '''guess value must be within the range of lower and higher value''' ) def answer(snake_case_ :int ) -> str: if number > to_guess: return "high" elif number < to_guess: return "low" else: return "same" print('''started...''' ) __UpperCAmelCase = lower __UpperCAmelCase = higher __UpperCAmelCase = [] while True: __UpperCAmelCase = get_avg(snake_case_ , snake_case_ ) last_numbers.append(snake_case_ ) if answer(snake_case_ ) == "low": __UpperCAmelCase = number elif answer(snake_case_ ) == "high": __UpperCAmelCase = number else: break print(F'''guess the number : {last_numbers[-1]}''' ) print(F'''details : {last_numbers!s}''' ) def lowercase__ ( ): __UpperCAmelCase = int(input('''Enter lower value : ''' ).strip() ) __UpperCAmelCase = int(input('''Enter high value : ''' ).strip() ) __UpperCAmelCase = int(input('''Enter value to guess : ''' ).strip() ) guess_the_number(snake_case_ , snake_case_ , snake_case_ ) if __name__ == "__main__": main()
332
"""simple docstring""" import numpy as np from numpy import ndarray from scipy.optimize import Bounds, LinearConstraint, minimize def lowercase__ ( snake_case_ :ndarray ): return np.dot(snake_case_ , snake_case_ ) class _UpperCAmelCase : def __init__( self : Union[str, Any] , *, _lowercase : float = np.inf , _lowercase : str = "linear" , _lowercase : float = 0.0 , ): __UpperCAmelCase = regularization __UpperCAmelCase = gamma if kernel == "linear": __UpperCAmelCase = self.__linear elif kernel == "rbf": if self.gamma == 0: raise ValueError('''rbf kernel requires gamma''' ) if not isinstance(self.gamma , (float, int) ): raise ValueError('''gamma must be float or int''' ) if not self.gamma > 0: raise ValueError('''gamma must be > 0''' ) __UpperCAmelCase = self.__rbf # in the future, there could be a default value like in sklearn # sklear: def_gamma = 1/(n_features * X.var()) (wiki) # previously it was 1/(n_features) else: __UpperCAmelCase = F'''Unknown kernel: {kernel}''' raise ValueError(_lowercase ) def a ( self : Dict , _lowercase : ndarray , _lowercase : ndarray ): return np.dot(_lowercase , _lowercase ) def a ( self : Any , _lowercase : ndarray , _lowercase : ndarray ): return np.exp(-(self.gamma * norm_squared(vectora - vectora )) ) def a ( self : Union[str, Any] , _lowercase : list[ndarray] , _lowercase : ndarray ): __UpperCAmelCase = observations __UpperCAmelCase = classes # using Wolfe's Dual to calculate w. # Primal problem: minimize 1/2*norm_squared(w) # constraint: yn(w . xn + b) >= 1 # # With l a vector # Dual problem: maximize sum_n(ln) - # 1/2 * sum_n(sum_m(ln*lm*yn*ym*xn . xm)) # constraint: self.C >= ln >= 0 # and sum_n(ln*yn) = 0 # Then we get w using w = sum_n(ln*yn*xn) # At the end we can get b ~= mean(yn - w . xn) # # Since we use kernels, we only need l_star to calculate b # and to classify observations ((__UpperCAmelCase) , ) = np.shape(_lowercase ) def to_minimize(_lowercase : ndarray ) -> float: __UpperCAmelCase = 0 ((__UpperCAmelCase) , ) = np.shape(_lowercase ) for i in range(_lowercase ): for j in range(_lowercase ): s += ( candidate[i] * candidate[j] * classes[i] * classes[j] * self.kernel(observations[i] , observations[j] ) ) return 1 / 2 * s - sum(_lowercase ) __UpperCAmelCase = LinearConstraint(_lowercase , 0 , 0 ) __UpperCAmelCase = Bounds(0 , self.regularization ) __UpperCAmelCase = minimize( _lowercase , np.ones(_lowercase ) , bounds=_lowercase , constraints=[ly_contraint] ).x __UpperCAmelCase = l_star # calculating mean offset of separation plane to points __UpperCAmelCase = 0 for i in range(_lowercase ): for j in range(_lowercase ): s += classes[i] - classes[i] * self.optimum[i] * self.kernel( observations[i] , observations[j] ) __UpperCAmelCase = s / n def a ( self : List[Any] , _lowercase : ndarray ): __UpperCAmelCase = sum( self.optimum[n] * self.classes[n] * self.kernel(self.observations[n] , _lowercase ) for n in range(len(self.classes ) ) ) return 1 if s + self.offset >= 0 else -1 if __name__ == "__main__": import doctest doctest.testmod()
332
1
"""simple docstring""" import unittest from transformers import BarthezTokenizer, BarthezTokenizerFast, BatchEncoding from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow from ...test_tokenization_common import TokenizerTesterMixin @require_tokenizers @require_sentencepiece @slow # see https://github.com/huggingface/transformers/issues/11457 class _UpperCAmelCase ( _lowerCAmelCase , unittest.TestCase ): a__ : Optional[int] = BarthezTokenizer a__ : int = BarthezTokenizerFast a__ : Optional[Any] = True a__ : int = True def a ( self : Union[str, Any] ): super().setUp() __UpperCAmelCase = BarthezTokenizerFast.from_pretrained('''moussaKam/mbarthez''' ) tokenizer.save_pretrained(self.tmpdirname ) tokenizer.save_pretrained(self.tmpdirname , legacy_format=_lowercase ) __UpperCAmelCase = tokenizer def a ( self : str ): __UpperCAmelCase = '''<pad>''' __UpperCAmelCase = 1 self.assertEqual(self.get_tokenizer()._convert_token_to_id(_lowercase ) , _lowercase ) self.assertEqual(self.get_tokenizer()._convert_id_to_token(_lowercase ) , _lowercase ) def a ( self : Optional[Any] ): __UpperCAmelCase = list(self.get_tokenizer().get_vocab().keys() ) self.assertEqual(vocab_keys[0] , '''<s>''' ) self.assertEqual(vocab_keys[1] , '''<pad>''' ) self.assertEqual(vocab_keys[-1] , '''<mask>''' ) self.assertEqual(len(_lowercase ) , 10_11_22 ) def a ( self : Dict ): self.assertEqual(self.get_tokenizer().vocab_size , 10_11_22 ) @require_torch def a ( self : Union[str, Any] ): __UpperCAmelCase = ['''A long paragraph for summarization.''', '''Another paragraph for summarization.'''] __UpperCAmelCase = [0, 57, 30_18, 7_03_07, 91, 2] __UpperCAmelCase = self.tokenizer( _lowercase , max_length=len(_lowercase ) , padding=_lowercase , truncation=_lowercase , return_tensors='''pt''' ) self.assertIsInstance(_lowercase , _lowercase ) self.assertEqual((2, 6) , batch.input_ids.shape ) self.assertEqual((2, 6) , batch.attention_mask.shape ) __UpperCAmelCase = batch.input_ids.tolist()[0] self.assertListEqual(_lowercase , _lowercase ) def a ( self : Tuple ): if not self.test_rust_tokenizer: return __UpperCAmelCase = self.get_tokenizer() __UpperCAmelCase = self.get_rust_tokenizer() __UpperCAmelCase = '''I was born in 92000, and this is falsé.''' __UpperCAmelCase = tokenizer.tokenize(_lowercase ) __UpperCAmelCase = rust_tokenizer.tokenize(_lowercase ) self.assertListEqual(_lowercase , _lowercase ) __UpperCAmelCase = tokenizer.encode(_lowercase , add_special_tokens=_lowercase ) __UpperCAmelCase = rust_tokenizer.encode(_lowercase , add_special_tokens=_lowercase ) self.assertListEqual(_lowercase , _lowercase ) __UpperCAmelCase = self.get_rust_tokenizer() __UpperCAmelCase = tokenizer.encode(_lowercase ) __UpperCAmelCase = rust_tokenizer.encode(_lowercase ) self.assertListEqual(_lowercase , _lowercase ) @slow def a ( self : str ): # fmt: off __UpperCAmelCase = {'''input_ids''': [[0, 4_90, 1_43_28, 45_07, 3_54, 47, 4_36_69, 95, 25, 7_81_17, 2_02_15, 1_97_79, 1_90, 22, 4_00, 4, 3_53_43, 8_03_10, 6_03, 86, 2_49_37, 1_05, 3_34_38, 9_47_62, 1_96, 3_96_42, 7, 15, 1_59_33, 1_73, 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], [0, 1_05_34, 87, 25, 66, 33_58, 1_96, 5_52_89, 8, 8_29_61, 81, 22_04, 7_52_03, 7, 15, 7_63, 1_29_56, 2_16, 1_78, 1_43_28, 95_95, 13_77, 6_96_93, 7, 4_48, 7_10_21, 1_96, 1_81_06, 14_37, 1_39_74, 1_08, 90_83, 4, 4_93_15, 7, 39, 86, 13_26, 27_93, 4_63_33, 4, 4_48, 1_96, 7_45_88, 7, 4_93_15, 7, 39, 21, 8_22, 3_84_70, 74, 21, 6_67_23, 6_24_80, 8, 2_20_50, 5, 2]], '''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, 0, 0, 0, 0, 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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]} # noqa: E501 # fmt: on # moussaKam/mbarthez is a french model. So we also use french texts. __UpperCAmelCase = [ '''Le transformeur est un modèle d\'apprentissage profond introduit en 2017, ''' '''utilisé principalement dans le domaine du traitement automatique des langues (TAL).''', '''À l\'instar des réseaux de neurones récurrents (RNN), les transformeurs sont conçus ''' '''pour gérer des données séquentielles, telles que le langage naturel, pour des tâches ''' '''telles que la traduction et la synthèse de texte.''', ] self.tokenizer_integration_test_util( expected_encoding=_lowercase , model_name='''moussaKam/mbarthez''' , revision='''c2e4ecbca5e3cd2c37fe1ac285ca4fbdf1366fb6''' , sequences=_lowercase , )
332
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import _LazyModule _lowercase : int = {'processing_wav2vec2_with_lm': ['Wav2Vec2ProcessorWithLM']} if TYPE_CHECKING: from .processing_wavaveca_with_lm import WavaVecaProcessorWithLM else: import sys _lowercase : Union[str, Any] = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
332
1
"""simple docstring""" def lowercase__ ( snake_case_ :float , snake_case_ :float , snake_case_ :int ): if principal <= 0: raise Exception('''Principal borrowed must be > 0''' ) if rate_per_annum < 0: raise Exception('''Rate of interest must be >= 0''' ) if years_to_repay <= 0 or not isinstance(snake_case_ , snake_case_ ): raise Exception('''Years to repay must be an integer > 0''' ) # Yearly rate is divided by 12 to get monthly rate __UpperCAmelCase = rate_per_annum / 12 # Years to repay is multiplied by 12 to get number of payments as payment is monthly __UpperCAmelCase = years_to_repay * 12 return ( principal * rate_per_month * (1 + rate_per_month) ** number_of_payments / ((1 + rate_per_month) ** number_of_payments - 1) ) if __name__ == "__main__": import doctest doctest.testmod()
332
"""simple docstring""" from __future__ import annotations class _UpperCAmelCase : def __init__( self : Tuple , _lowercase : str , _lowercase : str ): __UpperCAmelCase , __UpperCAmelCase = text, pattern __UpperCAmelCase , __UpperCAmelCase = len(_lowercase ), len(_lowercase ) def a ( self : Optional[int] , _lowercase : str ): for i in range(self.patLen - 1 , -1 , -1 ): if char == self.pattern[i]: return i return -1 def a ( self : int , _lowercase : int ): for i in range(self.patLen - 1 , -1 , -1 ): if self.pattern[i] != self.text[current_pos + i]: return current_pos + i return -1 def a ( self : Optional[Any] ): # searches pattern in text and returns index positions __UpperCAmelCase = [] for i in range(self.textLen - self.patLen + 1 ): __UpperCAmelCase = self.mismatch_in_text(_lowercase ) if mismatch_index == -1: positions.append(_lowercase ) else: __UpperCAmelCase = self.match_in_pattern(self.text[mismatch_index] ) __UpperCAmelCase = ( mismatch_index - match_index ) # shifting index lgtm [py/multiple-definition] return positions _lowercase : str = 'ABAABA' _lowercase : Tuple = 'AB' _lowercase : Dict = BoyerMooreSearch(text, pattern) _lowercase : Any = bms.bad_character_heuristic() if len(positions) == 0: print('No match found') else: print('Pattern found in following positions: ') print(positions)
332
1
"""simple docstring""" import os def lowercase__ ( snake_case_ :str = "input.txt" ): with open(os.path.join(os.path.dirname(snake_case_ ) , snake_case_ ) ) as input_file: __UpperCAmelCase = [ [int(snake_case_ ) for element in line.split(''',''' )] for line in input_file.readlines() ] __UpperCAmelCase = len(snake_case_ ) __UpperCAmelCase = len(matrix[0] ) __UpperCAmelCase = [[-1 for _ in range(snake_case_ )] for _ in range(snake_case_ )] for i in range(snake_case_ ): __UpperCAmelCase = matrix[i][0] for j in range(1 , snake_case_ ): for i in range(snake_case_ ): __UpperCAmelCase = minimal_path_sums[i][j - 1] + matrix[i][j] for i in range(1 , snake_case_ ): __UpperCAmelCase = min( minimal_path_sums[i][j] , minimal_path_sums[i - 1][j] + matrix[i][j] ) for i in range(rows - 2 , -1 , -1 ): __UpperCAmelCase = min( minimal_path_sums[i][j] , minimal_path_sums[i + 1][j] + matrix[i][j] ) return min(minimal_path_sums_row[-1] for minimal_path_sums_row in minimal_path_sums ) if __name__ == "__main__": print(f"""{solution() = }""")
332
"""simple docstring""" from __future__ import annotations from collections import deque from collections.abc import Sequence from dataclasses import dataclass from typing import Any @dataclass class _UpperCAmelCase : a__ : int a__ : Node | None = None a__ : Node | None = None def lowercase__ ( ): __UpperCAmelCase = Node(1 ) __UpperCAmelCase = Node(2 ) __UpperCAmelCase = Node(3 ) __UpperCAmelCase = Node(4 ) __UpperCAmelCase = Node(5 ) return tree def lowercase__ ( snake_case_ :Node | None ): return [root.data, *preorder(root.left ), *preorder(root.right )] if root else [] def lowercase__ ( snake_case_ :Node | None ): return postorder(root.left ) + postorder(root.right ) + [root.data] if root else [] def lowercase__ ( snake_case_ :Node | None ): return [*inorder(root.left ), root.data, *inorder(root.right )] if root else [] def lowercase__ ( snake_case_ :Node | None ): return (max(height(root.left ) , height(root.right ) ) + 1) if root else 0 def lowercase__ ( snake_case_ :Node | None ): __UpperCAmelCase = [] if root is None: return output __UpperCAmelCase = deque([root] ) while process_queue: __UpperCAmelCase = process_queue.popleft() output.append(node.data ) if node.left: process_queue.append(node.left ) if node.right: process_queue.append(node.right ) return output def lowercase__ ( snake_case_ :Node | None , snake_case_ :int ): __UpperCAmelCase = [] def populate_output(snake_case_ :Node | None , snake_case_ :int ) -> None: if not root: return if level == 1: output.append(root.data ) elif level > 1: populate_output(root.left , level - 1 ) populate_output(root.right , level - 1 ) populate_output(snake_case_ , snake_case_ ) return output def lowercase__ ( snake_case_ :Node | None , snake_case_ :int ): __UpperCAmelCase = [] def populate_output(snake_case_ :Node | None , snake_case_ :int ) -> None: if root is None: return if level == 1: output.append(root.data ) elif level > 1: populate_output(root.right , level - 1 ) populate_output(root.left , level - 1 ) populate_output(snake_case_ , snake_case_ ) return output def lowercase__ ( snake_case_ :Node | None ): if root is None: return [] __UpperCAmelCase = [] __UpperCAmelCase = 0 __UpperCAmelCase = height(snake_case_ ) for h in range(1 , height_tree + 1 ): if not flag: output.append(get_nodes_from_left_to_right(snake_case_ , snake_case_ ) ) __UpperCAmelCase = 1 else: output.append(get_nodes_from_right_to_left(snake_case_ , snake_case_ ) ) __UpperCAmelCase = 0 return output def lowercase__ ( ): # Main function for testing. __UpperCAmelCase = make_tree() print(F'''In-order Traversal: {inorder(snake_case_ )}''' ) print(F'''Pre-order Traversal: {preorder(snake_case_ )}''' ) print(F'''Post-order Traversal: {postorder(snake_case_ )}''' , '''\n''' ) print(F'''Height of Tree: {height(snake_case_ )}''' , '''\n''' ) print('''Complete Level Order Traversal: ''' ) print(level_order(snake_case_ ) , '''\n''' ) print('''Level-wise order Traversal: ''' ) for level in range(1 , height(snake_case_ ) + 1 ): print(F'''Level {level}:''' , get_nodes_from_left_to_right(snake_case_ , level=snake_case_ ) ) print('''\nZigZag order Traversal: ''' ) print(zigzag(snake_case_ ) ) if __name__ == "__main__": import doctest doctest.testmod() main()
332
1
"""simple docstring""" _lowercase : str = '\n# Transformers installation\n! pip install transformers datasets\n# To install from source instead of the last release, comment the command above and uncomment the following one.\n# ! pip install git+https://github.com/huggingface/transformers.git\n' _lowercase : str = [{'type': 'code', 'content': INSTALL_CONTENT}] _lowercase : Any = { '{processor_class}': 'FakeProcessorClass', '{model_class}': 'FakeModelClass', '{object_class}': 'FakeObjectClass', }
332
"""simple docstring""" import unittest from transformers import is_torch_available from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow if is_torch_available(): import torch from transformers import XLMRobertaModel @require_sentencepiece @require_tokenizers @require_torch class _UpperCAmelCase ( unittest.TestCase ): @slow def a ( self : str ): __UpperCAmelCase = XLMRobertaModel.from_pretrained('''xlm-roberta-base''' ) __UpperCAmelCase = torch.tensor([[0, 5_81, 1_02_69, 83, 9_99_42, 1_36, 6_07_42, 23, 70, 8_05_83, 1_82_76, 2]] ) # The dog is cute and lives in the garden house __UpperCAmelCase = torch.Size((1, 12, 7_68) ) # batch_size, sequence_length, embedding_vector_dim __UpperCAmelCase = torch.tensor( [[-0.0_101, 0.1_218, -0.0_803, 0.0_801, 0.1_327, 0.0_776, -0.1_215, 0.2_383, 0.3_338, 0.3_106, 0.0_300, 0.0_252]] ) # xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.base') # xlmr.eval() # expected_output_values_last_dim = xlmr.extract_features(input_ids[0])[:, :, -1] with torch.no_grad(): __UpperCAmelCase = model(_lowercase )['''last_hidden_state'''].detach() self.assertEqual(output.shape , _lowercase ) # compare the actual values for a slice of last dim self.assertTrue(torch.allclose(output[:, :, -1] , _lowercase , atol=1E-3 ) ) @slow def a ( self : str ): __UpperCAmelCase = XLMRobertaModel.from_pretrained('''xlm-roberta-large''' ) __UpperCAmelCase = torch.tensor([[0, 5_81, 1_02_69, 83, 9_99_42, 1_36, 6_07_42, 23, 70, 8_05_83, 1_82_76, 2]] ) # The dog is cute and lives in the garden house __UpperCAmelCase = torch.Size((1, 12, 10_24) ) # batch_size, sequence_length, embedding_vector_dim __UpperCAmelCase = torch.tensor( [[-0.0_699, -0.0_318, 0.0_705, -0.1_241, 0.0_999, -0.0_520, 0.1_004, -0.1_838, -0.4_704, 0.1_437, 0.0_821, 0.0_126]] ) # xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.large') # xlmr.eval() # expected_output_values_last_dim = xlmr.extract_features(input_ids[0])[:, :, -1] with torch.no_grad(): __UpperCAmelCase = model(_lowercase )['''last_hidden_state'''].detach() self.assertEqual(output.shape , _lowercase ) # compare the actual values for a slice of last dim self.assertTrue(torch.allclose(output[:, :, -1] , _lowercase , atol=1E-3 ) )
332
1
"""simple docstring""" import gc import random import unittest import numpy as np import torch from PIL import Image from diffusers import ( DDIMScheduler, KandinskyVaaImgaImgPipeline, KandinskyVaaPriorPipeline, UNetaDConditionModel, VQModel, ) from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference enable_full_determinism() class _UpperCAmelCase ( _lowerCAmelCase , unittest.TestCase ): a__ : List[str] = KandinskyVaaImgaImgPipeline a__ : Dict = ["image_embeds", "negative_image_embeds", "image"] a__ : int = [ "image_embeds", "negative_image_embeds", "image", ] a__ : int = [ "generator", "height", "width", "strength", "guidance_scale", "num_inference_steps", "return_dict", "guidance_scale", "num_images_per_prompt", "output_type", "return_dict", ] a__ : Tuple = False @property def a ( self : List[str] ): return 32 @property def a ( self : Any ): return 32 @property def a ( self : Union[str, Any] ): return self.time_input_dim @property def a ( self : Union[str, Any] ): return self.time_input_dim * 4 @property def a ( self : Union[str, Any] ): return 1_00 @property def a ( self : Optional[int] ): torch.manual_seed(0 ) __UpperCAmelCase = { '''in_channels''': 4, # Out channels is double in channels because predicts mean and variance '''out_channels''': 8, '''addition_embed_type''': '''image''', '''down_block_types''': ('''ResnetDownsampleBlock2D''', '''SimpleCrossAttnDownBlock2D'''), '''up_block_types''': ('''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D'''), '''mid_block_type''': '''UNetMidBlock2DSimpleCrossAttn''', '''block_out_channels''': (self.block_out_channels_a, self.block_out_channels_a * 2), '''layers_per_block''': 1, '''encoder_hid_dim''': self.text_embedder_hidden_size, '''encoder_hid_dim_type''': '''image_proj''', '''cross_attention_dim''': self.cross_attention_dim, '''attention_head_dim''': 4, '''resnet_time_scale_shift''': '''scale_shift''', '''class_embed_type''': None, } __UpperCAmelCase = UNetaDConditionModel(**_lowercase ) return model @property def a ( self : Optional[Any] ): return { "block_out_channels": [32, 64], "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"], "in_channels": 3, "latent_channels": 4, "layers_per_block": 1, "norm_num_groups": 8, "norm_type": "spatial", "num_vq_embeddings": 12, "out_channels": 3, "up_block_types": [ "AttnUpDecoderBlock2D", "UpDecoderBlock2D", ], "vq_embed_dim": 4, } @property def a ( self : List[Any] ): torch.manual_seed(0 ) __UpperCAmelCase = VQModel(**self.dummy_movq_kwargs ) return model def a ( self : Dict ): __UpperCAmelCase = self.dummy_unet __UpperCAmelCase = self.dummy_movq __UpperCAmelCase = { '''num_train_timesteps''': 10_00, '''beta_schedule''': '''linear''', '''beta_start''': 0.00_085, '''beta_end''': 0.012, '''clip_sample''': False, '''set_alpha_to_one''': False, '''steps_offset''': 0, '''prediction_type''': '''epsilon''', '''thresholding''': False, } __UpperCAmelCase = DDIMScheduler(**_lowercase ) __UpperCAmelCase = { '''unet''': unet, '''scheduler''': scheduler, '''movq''': movq, } return components def a ( self : Union[str, Any] , _lowercase : str , _lowercase : Optional[Any]=0 ): __UpperCAmelCase = floats_tensor((1, self.text_embedder_hidden_size) , rng=random.Random(_lowercase ) ).to(_lowercase ) __UpperCAmelCase = floats_tensor((1, self.text_embedder_hidden_size) , rng=random.Random(seed + 1 ) ).to( _lowercase ) # create init_image __UpperCAmelCase = floats_tensor((1, 3, 64, 64) , rng=random.Random(_lowercase ) ).to(_lowercase ) __UpperCAmelCase = image.cpu().permute(0 , 2 , 3 , 1 )[0] __UpperCAmelCase = Image.fromarray(np.uinta(_lowercase ) ).convert('''RGB''' ).resize((2_56, 2_56) ) if str(_lowercase ).startswith('''mps''' ): __UpperCAmelCase = torch.manual_seed(_lowercase ) else: __UpperCAmelCase = torch.Generator(device=_lowercase ).manual_seed(_lowercase ) __UpperCAmelCase = { '''image''': init_image, '''image_embeds''': image_embeds, '''negative_image_embeds''': negative_image_embeds, '''generator''': generator, '''height''': 64, '''width''': 64, '''num_inference_steps''': 10, '''guidance_scale''': 7.0, '''strength''': 0.2, '''output_type''': '''np''', } return inputs def a ( self : List[Any] ): __UpperCAmelCase = '''cpu''' __UpperCAmelCase = self.get_dummy_components() __UpperCAmelCase = self.pipeline_class(**_lowercase ) __UpperCAmelCase = pipe.to(_lowercase ) pipe.set_progress_bar_config(disable=_lowercase ) __UpperCAmelCase = pipe(**self.get_dummy_inputs(_lowercase ) ) __UpperCAmelCase = output.images __UpperCAmelCase = pipe( **self.get_dummy_inputs(_lowercase ) , return_dict=_lowercase , )[0] __UpperCAmelCase = image[0, -3:, -3:, -1] __UpperCAmelCase = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) __UpperCAmelCase = np.array( [0.6_199_778, 0.63_984_406, 0.46_145_785, 0.62_944_984, 0.5_622_215, 0.47_306_132, 0.47_441_456, 0.4_607_606, 0.48_719_263] ) assert ( np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2 ), F''' expected_slice {expected_slice}, but got {image_slice.flatten()}''' assert ( np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1E-2 ), F''' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}''' @slow @require_torch_gpu class _UpperCAmelCase ( unittest.TestCase ): def a ( self : Union[str, Any] ): # clean up the VRAM after each test super().tearDown() gc.collect() torch.cuda.empty_cache() def a ( self : Optional[Any] ): __UpperCAmelCase = load_numpy( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/kandinskyv22/kandinskyv22_img2img_frog.npy''' ) __UpperCAmelCase = load_image( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/kandinsky/cat.png''' ) __UpperCAmelCase = '''A red cartoon frog, 4k''' __UpperCAmelCase = KandinskyVaaPriorPipeline.from_pretrained( '''kandinsky-community/kandinsky-2-2-prior''' , torch_dtype=torch.floataa ) pipe_prior.to(_lowercase ) __UpperCAmelCase = KandinskyVaaImgaImgPipeline.from_pretrained( '''kandinsky-community/kandinsky-2-2-decoder''' , torch_dtype=torch.floataa ) __UpperCAmelCase = pipeline.to(_lowercase ) pipeline.set_progress_bar_config(disable=_lowercase ) __UpperCAmelCase = torch.Generator(device='''cpu''' ).manual_seed(0 ) __UpperCAmelCase , __UpperCAmelCase = pipe_prior( _lowercase , generator=_lowercase , num_inference_steps=5 , negative_prompt='''''' , ).to_tuple() __UpperCAmelCase = pipeline( image=_lowercase , image_embeds=_lowercase , negative_image_embeds=_lowercase , generator=_lowercase , num_inference_steps=1_00 , height=7_68 , width=7_68 , strength=0.2 , output_type='''np''' , ) __UpperCAmelCase = output.images[0] assert image.shape == (7_68, 7_68, 3) assert_mean_pixel_difference(_lowercase , _lowercase )
332
"""simple docstring""" def lowercase__ ( snake_case_ :Union[str, Any] ): # if the collection is empty, returns empty if collection == []: return [] # get some information about the collection __UpperCAmelCase = len(snake_case_ ) __UpperCAmelCase = max(snake_case_ ) __UpperCAmelCase = min(snake_case_ ) # create the counting array __UpperCAmelCase = coll_max + 1 - coll_min __UpperCAmelCase = [0] * counting_arr_length # count how much a number appears in the collection for number in collection: counting_arr[number - coll_min] += 1 # sum each position with it's predecessors. now, counting_arr[i] tells # us how many elements <= i has in the collection for i in range(1 , snake_case_ ): __UpperCAmelCase = counting_arr[i] + counting_arr[i - 1] # create the output collection __UpperCAmelCase = [0] * coll_len # place the elements in the output, respecting the original order (stable # sort) from end to begin, updating counting_arr for i in reversed(range(0 , snake_case_ ) ): __UpperCAmelCase = collection[i] counting_arr[collection[i] - coll_min] -= 1 return ordered def lowercase__ ( snake_case_ :str ): return "".join([chr(snake_case_ ) for i in counting_sort([ord(snake_case_ ) for c in string] )] ) if __name__ == "__main__": # Test string sort assert counting_sort_string('thisisthestring') == "eghhiiinrsssttt" _lowercase : int = input('Enter numbers separated by a comma:\n').strip() _lowercase : int = [int(item) for item in user_input.split(',')] print(counting_sort(unsorted))
332
1
"""simple docstring""" import os import unicodedata from shutil import copyfile from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import AddedToken, PreTrainedTokenizer from ...utils import logging _lowercase : Optional[Any] = logging.get_logger(__name__) _lowercase : List[str] = {'vocab_file': 'spiece.model'} _lowercase : str = { 'vocab_file': { 'albert-base-v1': 'https://huggingface.co/albert-base-v1/resolve/main/spiece.model', 'albert-large-v1': 'https://huggingface.co/albert-large-v1/resolve/main/spiece.model', 'albert-xlarge-v1': 'https://huggingface.co/albert-xlarge-v1/resolve/main/spiece.model', 'albert-xxlarge-v1': 'https://huggingface.co/albert-xxlarge-v1/resolve/main/spiece.model', 'albert-base-v2': 'https://huggingface.co/albert-base-v2/resolve/main/spiece.model', 'albert-large-v2': 'https://huggingface.co/albert-large-v2/resolve/main/spiece.model', 'albert-xlarge-v2': 'https://huggingface.co/albert-xlarge-v2/resolve/main/spiece.model', 'albert-xxlarge-v2': 'https://huggingface.co/albert-xxlarge-v2/resolve/main/spiece.model', } } _lowercase : List[Any] = { 'albert-base-v1': 5_12, 'albert-large-v1': 5_12, 'albert-xlarge-v1': 5_12, 'albert-xxlarge-v1': 5_12, 'albert-base-v2': 5_12, 'albert-large-v2': 5_12, 'albert-xlarge-v2': 5_12, 'albert-xxlarge-v2': 5_12, } _lowercase : Any = '▁' class _UpperCAmelCase ( _lowerCAmelCase ): a__ : int = VOCAB_FILES_NAMES a__ : Union[str, Any] = PRETRAINED_VOCAB_FILES_MAP a__ : List[str] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES def __init__( self : Dict , _lowercase : List[Any] , _lowercase : Union[str, Any]=True , _lowercase : Union[str, Any]=True , _lowercase : str=False , _lowercase : str="[CLS]" , _lowercase : Union[str, Any]="[SEP]" , _lowercase : Optional[Any]="<unk>" , _lowercase : Optional[int]="[SEP]" , _lowercase : Tuple="<pad>" , _lowercase : int="[CLS]" , _lowercase : Tuple="[MASK]" , _lowercase : Optional[Dict[str, Any]] = None , **_lowercase : Any , ): # Mask token behave like a normal word, i.e. include the space before it and # is included in the raw text, there should be a match in a non-normalized sentence. __UpperCAmelCase = ( AddedToken(_lowercase , lstrip=_lowercase , rstrip=_lowercase , normalized=_lowercase ) if isinstance(_lowercase , _lowercase ) else mask_token ) __UpperCAmelCase = {} if sp_model_kwargs is None else sp_model_kwargs super().__init__( do_lower_case=_lowercase , remove_space=_lowercase , keep_accents=_lowercase , bos_token=_lowercase , eos_token=_lowercase , unk_token=_lowercase , sep_token=_lowercase , pad_token=_lowercase , cls_token=_lowercase , mask_token=_lowercase , sp_model_kwargs=self.sp_model_kwargs , **_lowercase , ) __UpperCAmelCase = do_lower_case __UpperCAmelCase = remove_space __UpperCAmelCase = keep_accents __UpperCAmelCase = vocab_file __UpperCAmelCase = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(_lowercase ) @property def a ( self : Optional[int] ): return len(self.sp_model ) def a ( self : Union[str, Any] ): __UpperCAmelCase = {self.convert_ids_to_tokens(_lowercase ): i for i in range(self.vocab_size )} vocab.update(self.added_tokens_encoder ) return vocab def __getstate__( self : Tuple ): __UpperCAmelCase = self.__dict__.copy() __UpperCAmelCase = None return state def __setstate__( self : Union[str, Any] , _lowercase : List[str] ): __UpperCAmelCase = d # for backward compatibility if not hasattr(self , '''sp_model_kwargs''' ): __UpperCAmelCase = {} __UpperCAmelCase = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(self.vocab_file ) def a ( self : Any , _lowercase : List[Any] ): if self.remove_space: __UpperCAmelCase = ''' '''.join(inputs.strip().split() ) else: __UpperCAmelCase = inputs __UpperCAmelCase = outputs.replace('''``''' , '''"''' ).replace('''\'\'''' , '''"''' ) if not self.keep_accents: __UpperCAmelCase = unicodedata.normalize('''NFKD''' , _lowercase ) __UpperCAmelCase = ''''''.join([c for c in outputs if not unicodedata.combining(_lowercase )] ) if self.do_lower_case: __UpperCAmelCase = outputs.lower() return outputs def a ( self : Any , _lowercase : str ): __UpperCAmelCase = self.preprocess_text(_lowercase ) __UpperCAmelCase = self.sp_model.encode(_lowercase , out_type=_lowercase ) __UpperCAmelCase = [] for piece in pieces: if len(_lowercase ) > 1 and piece[-1] == str(''',''' ) and piece[-2].isdigit(): __UpperCAmelCase = self.sp_model.EncodeAsPieces(piece[:-1].replace(_lowercase , '''''' ) ) if piece[0] != SPIECE_UNDERLINE and cur_pieces[0][0] == SPIECE_UNDERLINE: if len(cur_pieces[0] ) == 1: __UpperCAmelCase = cur_pieces[1:] else: __UpperCAmelCase = cur_pieces[0][1:] cur_pieces.append(piece[-1] ) new_pieces.extend(_lowercase ) else: new_pieces.append(_lowercase ) return new_pieces def a ( self : Optional[Any] , _lowercase : List[Any] ): return self.sp_model.PieceToId(_lowercase ) def a ( self : List[str] , _lowercase : Optional[int] ): return self.sp_model.IdToPiece(_lowercase ) def a ( self : Optional[Any] , _lowercase : List[Any] ): __UpperCAmelCase = [] __UpperCAmelCase = '''''' __UpperCAmelCase = False for token in tokens: # make sure that special tokens are not decoded using sentencepiece model if token in self.all_special_tokens: if not prev_is_special: out_string += " " out_string += self.sp_model.decode(_lowercase ) + token __UpperCAmelCase = True __UpperCAmelCase = [] else: current_sub_tokens.append(_lowercase ) __UpperCAmelCase = False out_string += self.sp_model.decode(_lowercase ) return out_string.strip() def a ( self : List[Any] , _lowercase : List[int] , _lowercase : Optional[List[int]] = None ): __UpperCAmelCase = [self.sep_token_id] __UpperCAmelCase = [self.cls_token_id] if token_ids_a is None: return cls + token_ids_a + sep return cls + token_ids_a + sep + token_ids_a + sep def a ( self : Dict , _lowercase : List[int] , _lowercase : Optional[List[int]] = None , _lowercase : bool = False ): if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=_lowercase , token_ids_a=_lowercase , already_has_special_tokens=_lowercase ) if token_ids_a is not None: return [1] + ([0] * len(_lowercase )) + [1] + ([0] * len(_lowercase )) + [1] return [1] + ([0] * len(_lowercase )) + [1] def a ( self : Optional[Any] , _lowercase : List[int] , _lowercase : Optional[List[int]] = None ): __UpperCAmelCase = [self.sep_token_id] __UpperCAmelCase = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def a ( self : int , _lowercase : str , _lowercase : Optional[str] = None ): if not os.path.isdir(_lowercase ): logger.error(F'''Vocabulary path ({save_directory}) should be a directory''' ) return __UpperCAmelCase = os.path.join( _lowercase , (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file'''] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(_lowercase ) and os.path.isfile(self.vocab_file ): copyfile(self.vocab_file , _lowercase ) elif not os.path.isfile(self.vocab_file ): with open(_lowercase , '''wb''' ) as fi: __UpperCAmelCase = self.sp_model.serialized_model_proto() fi.write(_lowercase ) return (out_vocab_file,)
332
"""simple docstring""" from collections import defaultdict def lowercase__ ( snake_case_ :str , snake_case_ :str ): __UpperCAmelCase = first_str.lower().strip() __UpperCAmelCase = second_str.lower().strip() # Remove whitespace __UpperCAmelCase = first_str.replace(''' ''' , '''''' ) __UpperCAmelCase = second_str.replace(''' ''' , '''''' ) # Strings of different lengths are not anagrams if len(snake_case_ ) != len(snake_case_ ): return False # Default values for count should be 0 __UpperCAmelCase = defaultdict(snake_case_ ) # For each character in input strings, # increment count in the corresponding for i in range(len(snake_case_ ) ): 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() _lowercase : List[Any] = input('Enter the first string ').strip() _lowercase : Tuple = input('Enter the second string ').strip() _lowercase : str = check_anagrams(input_a, input_b) print(f"""{input_a} and {input_b} are {"" if status else "not "}anagrams.""")
332
1
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available _lowercase : str = { 'configuration_nezha': ['NEZHA_PRETRAINED_CONFIG_ARCHIVE_MAP', 'NezhaConfig'], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : str = [ 'NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST', 'NezhaForNextSentencePrediction', 'NezhaForMaskedLM', 'NezhaForPreTraining', 'NezhaForMultipleChoice', 'NezhaForQuestionAnswering', 'NezhaForSequenceClassification', 'NezhaForTokenClassification', 'NezhaModel', 'NezhaPreTrainedModel', ] if TYPE_CHECKING: from .configuration_nezha import NEZHA_PRETRAINED_CONFIG_ARCHIVE_MAP, NezhaConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_nezha import ( NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST, NezhaForMaskedLM, NezhaForMultipleChoice, NezhaForNextSentencePrediction, NezhaForPreTraining, NezhaForQuestionAnswering, NezhaForSequenceClassification, NezhaForTokenClassification, NezhaModel, NezhaPreTrainedModel, ) else: import sys _lowercase : Tuple = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
332
"""simple docstring""" import os import tempfile import unittest from pathlib import Path from transformers import AutoConfig, is_torch_available from transformers.testing_utils import require_torch, torch_device if is_torch_available(): from transformers import PyTorchBenchmark, PyTorchBenchmarkArguments @require_torch class _UpperCAmelCase ( unittest.TestCase ): def a ( self : Dict , _lowercase : Union[str, Any] ): for model_result in results.values(): for batch_size, sequence_length in zip(model_result['''bs'''] , model_result['''ss'''] ): __UpperCAmelCase = model_result['''result'''][batch_size][sequence_length] self.assertIsNotNone(_lowercase ) def a ( self : str ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : List[str] ): __UpperCAmelCase = '''sgugger/tiny-distilbert-classification''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , only_pretrain_model=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : str ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , torchscript=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) @unittest.skipIf(torch_device == '''cpu''' , '''Cant do half precision''' ) def a ( self : Optional[Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , fpaa=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : int ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) # set architectures equal to `None` __UpperCAmelCase = None __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : Tuple ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) @unittest.skipIf(torch_device == '''cpu''' , '''Can\'t do half precision''' ) def a ( self : Optional[Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , fpaa=_lowercase , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) def a ( self : Any ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : str ): __UpperCAmelCase = '''sshleifer/tinier_bart''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : Union[str, Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) def a ( self : int ): __UpperCAmelCase = '''sshleifer/tinier_bart''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) def a ( self : Optional[Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' with tempfile.TemporaryDirectory() as tmp_dir: __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , save_to_csv=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , inference_time_csv_file=os.path.join(_lowercase , '''inf_time.csv''' ) , train_memory_csv_file=os.path.join(_lowercase , '''train_mem.csv''' ) , inference_memory_csv_file=os.path.join(_lowercase , '''inf_mem.csv''' ) , train_time_csv_file=os.path.join(_lowercase , '''train_time.csv''' ) , env_info_csv_file=os.path.join(_lowercase , '''env.csv''' ) , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) benchmark.run() self.assertTrue(Path(os.path.join(_lowercase , '''inf_time.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(_lowercase , '''train_time.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(_lowercase , '''inf_mem.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(_lowercase , '''train_mem.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(_lowercase , '''env.csv''' ) ).exists() ) def a ( self : List[Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' def _check_summary_is_not_empty(_lowercase : str ): self.assertTrue(hasattr(_lowercase , '''sequential''' ) ) self.assertTrue(hasattr(_lowercase , '''cumulative''' ) ) self.assertTrue(hasattr(_lowercase , '''current''' ) ) self.assertTrue(hasattr(_lowercase , '''total''' ) ) with tempfile.TemporaryDirectory() as tmp_dir: __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , log_filename=os.path.join(_lowercase , '''log.txt''' ) , log_print=_lowercase , trace_memory_line_by_line=_lowercase , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() _check_summary_is_not_empty(result.inference_summary ) _check_summary_is_not_empty(result.train_summary ) self.assertTrue(Path(os.path.join(_lowercase , '''log.txt''' ) ).exists() )
332
1
"""simple docstring""" import argparse import torch from transformers import ( UniSpeechSatConfig, UniSpeechSatForAudioFrameClassification, UniSpeechSatForSequenceClassification, UniSpeechSatForXVector, WavaVecaFeatureExtractor, logging, ) logging.set_verbosity_info() _lowercase : Optional[int] = logging.get_logger(__name__) def lowercase__ ( snake_case_ :List[str] , snake_case_ :str , snake_case_ :List[Any] ): __UpperCAmelCase = UniSpeechSatForSequenceClassification.from_pretrained(snake_case_ , config=snake_case_ ) __UpperCAmelCase = downstream_dict['''projector.weight'''] __UpperCAmelCase = downstream_dict['''projector.bias'''] __UpperCAmelCase = downstream_dict['''model.post_net.linear.weight'''] __UpperCAmelCase = downstream_dict['''model.post_net.linear.bias'''] return model def lowercase__ ( snake_case_ :List[Any] , snake_case_ :List[Any] , snake_case_ :Tuple ): __UpperCAmelCase = UniSpeechSatForAudioFrameClassification.from_pretrained(snake_case_ , config=snake_case_ ) __UpperCAmelCase = downstream_dict['''model.linear.weight'''] __UpperCAmelCase = downstream_dict['''model.linear.bias'''] return model def lowercase__ ( snake_case_ :Any , snake_case_ :Optional[Any] , snake_case_ :Any ): __UpperCAmelCase = UniSpeechSatForXVector.from_pretrained(snake_case_ , config=snake_case_ ) __UpperCAmelCase = downstream_dict['''connector.weight'''] __UpperCAmelCase = downstream_dict['''connector.bias'''] for i, kernel_size in enumerate(hf_config.tdnn_kernel ): __UpperCAmelCase = downstream_dict[ F'''model.framelevel_feature_extractor.module.{i}.kernel.weight''' ] __UpperCAmelCase = downstream_dict[F'''model.framelevel_feature_extractor.module.{i}.kernel.bias'''] __UpperCAmelCase = downstream_dict['''model.utterancelevel_feature_extractor.linear1.weight'''] __UpperCAmelCase = downstream_dict['''model.utterancelevel_feature_extractor.linear1.bias'''] __UpperCAmelCase = downstream_dict['''model.utterancelevel_feature_extractor.linear2.weight'''] __UpperCAmelCase = downstream_dict['''model.utterancelevel_feature_extractor.linear2.bias'''] __UpperCAmelCase = downstream_dict['''objective.W'''] return model @torch.no_grad() def lowercase__ ( snake_case_ :str , snake_case_ :List[Any] , snake_case_ :str , snake_case_ :Union[str, Any] ): __UpperCAmelCase = torch.load(snake_case_ , map_location='''cpu''' ) __UpperCAmelCase = checkpoint['''Downstream'''] __UpperCAmelCase = UniSpeechSatConfig.from_pretrained(snake_case_ ) __UpperCAmelCase = WavaVecaFeatureExtractor.from_pretrained( snake_case_ , return_attention_mask=snake_case_ , do_normalize=snake_case_ ) __UpperCAmelCase = hf_config.architectures[0] if arch.endswith('''ForSequenceClassification''' ): __UpperCAmelCase = convert_classification(snake_case_ , snake_case_ , snake_case_ ) elif arch.endswith('''ForAudioFrameClassification''' ): __UpperCAmelCase = convert_diarization(snake_case_ , snake_case_ , snake_case_ ) elif arch.endswith('''ForXVector''' ): __UpperCAmelCase = convert_xvector(snake_case_ , snake_case_ , snake_case_ ) else: raise NotImplementedError(F'''S3PRL weights conversion is not supported for {arch}''' ) if hf_config.use_weighted_layer_sum: __UpperCAmelCase = checkpoint['''Featurizer''']['''weights'''] hf_feature_extractor.save_pretrained(snake_case_ ) hf_model.save_pretrained(snake_case_ ) if __name__ == "__main__": _lowercase : int = argparse.ArgumentParser() parser.add_argument( '--base_model_name', default=None, type=str, help='Name of the huggingface pretrained base model.' ) parser.add_argument('--config_path', default=None, type=str, help='Path to the huggingface classifier config.') parser.add_argument('--checkpoint_path', default=None, type=str, help='Path to the s3prl checkpoint.') parser.add_argument('--model_dump_path', default=None, type=str, help='Path to the final converted model.') _lowercase : Any = parser.parse_args() convert_saprl_checkpoint(args.base_model_name, args.config_path, args.checkpoint_path, args.model_dump_path)
332
"""simple docstring""" from typing import Dict from .base import GenericTensor, Pipeline class _UpperCAmelCase ( _lowerCAmelCase ): def a ( self : Tuple , _lowercase : Dict=None , _lowercase : str=None , _lowercase : Union[str, Any]=None , **_lowercase : Tuple ): if tokenize_kwargs is None: __UpperCAmelCase = {} if truncation is not None: if "truncation" in tokenize_kwargs: raise ValueError( '''truncation parameter defined twice (given as keyword argument as well as in tokenize_kwargs)''' ) __UpperCAmelCase = truncation __UpperCAmelCase = tokenize_kwargs __UpperCAmelCase = {} if return_tensors is not None: __UpperCAmelCase = return_tensors return preprocess_params, {}, postprocess_params def a ( self : int , _lowercase : Optional[Any] , **_lowercase : Union[str, Any] ): __UpperCAmelCase = self.framework __UpperCAmelCase = self.tokenizer(_lowercase , return_tensors=_lowercase , **_lowercase ) return model_inputs def a ( self : List[str] , _lowercase : Tuple ): __UpperCAmelCase = self.model(**_lowercase ) return model_outputs def a ( self : int , _lowercase : Tuple , _lowercase : str=False ): # [0] is the first available tensor, logits or last_hidden_state. if return_tensors: return model_outputs[0] if self.framework == "pt": return model_outputs[0].tolist() elif self.framework == "tf": return model_outputs[0].numpy().tolist() def __call__( self : List[Any] , *_lowercase : Optional[Any] , **_lowercase : Union[str, Any] ): return super().__call__(*_lowercase , **_lowercase )
332
1
"""simple docstring""" from __future__ import annotations def lowercase__ ( snake_case_ :list ): if len(snake_case_ ) == 0: return [] __UpperCAmelCase , __UpperCAmelCase = min(snake_case_ ), max(snake_case_ ) __UpperCAmelCase = int(max_value - min_value ) + 1 __UpperCAmelCase = [[] for _ in range(snake_case_ )] for i in my_list: buckets[int(i - min_value )].append(snake_case_ ) return [v for bucket in buckets for v in sorted(snake_case_ )] if __name__ == "__main__": from doctest import testmod testmod() assert bucket_sort([4, 5, 3, 2, 1]) == [1, 2, 3, 4, 5] assert bucket_sort([0, 1, -10, 15, 2, -2]) == [-10, -2, 0, 1, 2, 15]
332
"""simple docstring""" from typing import List, Optional, Tuple, Union import PIL import torch from torchvision import transforms from diffusers.pipeline_utils import DiffusionPipeline, ImagePipelineOutput from diffusers.schedulers import DDIMScheduler from diffusers.utils import randn_tensor _lowercase : Union[str, Any] = transforms.Compose( [ transforms.Resize((2_56, 2_56)), transforms.ToTensor(), transforms.Normalize([0.5], [0.5]), ] ) def lowercase__ ( snake_case_ :List[Any] ): if isinstance(snake_case_ , torch.Tensor ): return image elif isinstance(snake_case_ , PIL.Image.Image ): __UpperCAmelCase = [image] __UpperCAmelCase = [trans(img.convert('''RGB''' ) ) for img in image] __UpperCAmelCase = torch.stack(snake_case_ ) return image class _UpperCAmelCase ( _lowerCAmelCase ): def __init__( self : Any , _lowercase : str , _lowercase : str ): super().__init__() # make sure scheduler can always be converted to DDIM __UpperCAmelCase = DDIMScheduler.from_config(scheduler.config ) self.register_modules(unet=_lowercase , scheduler=_lowercase ) def a ( self : int , _lowercase : List[str] ): if strength < 0 or strength > 1: raise ValueError(F'''The value of strength should in [0.0, 1.0] but is {strength}''' ) def a ( self : List[Any] , _lowercase : List[Any] , _lowercase : Optional[Any] , _lowercase : int ): # get the original timestep using init_timestep __UpperCAmelCase = min(int(num_inference_steps * strength ) , _lowercase ) __UpperCAmelCase = max(num_inference_steps - init_timestep , 0 ) __UpperCAmelCase = self.scheduler.timesteps[t_start:] return timesteps, num_inference_steps - t_start def a ( self : Optional[Any] , _lowercase : Union[str, Any] , _lowercase : Union[str, Any] , _lowercase : Optional[Any] , _lowercase : List[str] , _lowercase : Tuple , _lowercase : Optional[int]=None ): if not isinstance(_lowercase , (torch.Tensor, PIL.Image.Image, list) ): raise ValueError( F'''`image` has to be of type `torch.Tensor`, `PIL.Image.Image` or list but is {type(_lowercase )}''' ) __UpperCAmelCase = image.to(device=_lowercase , dtype=_lowercase ) 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.''' ) __UpperCAmelCase = init_latents.shape __UpperCAmelCase = randn_tensor(_lowercase , generator=_lowercase , device=_lowercase , dtype=_lowercase ) # get latents print('''add noise to latents at timestep''' , _lowercase ) __UpperCAmelCase = self.scheduler.add_noise(_lowercase , _lowercase , _lowercase ) __UpperCAmelCase = init_latents return latents @torch.no_grad() def __call__( self : Any , _lowercase : Union[torch.FloatTensor, PIL.Image.Image] = None , _lowercase : float = 0.8 , _lowercase : int = 1 , _lowercase : Optional[Union[torch.Generator, List[torch.Generator]]] = None , _lowercase : float = 0.0 , _lowercase : int = 50 , _lowercase : Optional[bool] = None , _lowercase : Optional[str] = "pil" , _lowercase : bool = True , ): self.check_inputs(_lowercase ) # 2. Preprocess image __UpperCAmelCase = preprocess(_lowercase ) # 3. set timesteps self.scheduler.set_timesteps(_lowercase , device=self.device ) __UpperCAmelCase , __UpperCAmelCase = self.get_timesteps(_lowercase , _lowercase , self.device ) __UpperCAmelCase = timesteps[:1].repeat(_lowercase ) # 4. Prepare latent variables __UpperCAmelCase = self.prepare_latents(_lowercase , _lowercase , _lowercase , self.unet.dtype , self.device , _lowercase ) __UpperCAmelCase = latents # 5. Denoising loop for t in self.progress_bar(_lowercase ): # 1. predict noise model_output __UpperCAmelCase = 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 __UpperCAmelCase = self.scheduler.step( _lowercase , _lowercase , _lowercase , eta=_lowercase , use_clipped_model_output=_lowercase , generator=_lowercase , ).prev_sample __UpperCAmelCase = (image / 2 + 0.5).clamp(0 , 1 ) __UpperCAmelCase = image.cpu().permute(0 , 2 , 3 , 1 ).numpy() if output_type == "pil": __UpperCAmelCase = self.numpy_to_pil(_lowercase ) if not return_dict: return (image, latent_timestep.item()) return ImagePipelineOutput(images=_lowercase )
332
1
"""simple docstring""" _lowercase : Any = '\n# Transformers 설치 방법\n! pip install transformers datasets\n# 마지막 릴리스 대신 소스에서 설치하려면, 위 명령을 주석으로 바꾸고 아래 명령을 해제하세요.\n# ! pip install git+https://github.com/huggingface/transformers.git\n' _lowercase : Any = [{'type': 'code', 'content': INSTALL_CONTENT}] _lowercase : Any = { '{processor_class}': 'FakeProcessorClass', '{model_class}': 'FakeModelClass', '{object_class}': 'FakeObjectClass', }
332
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, ) _lowercase : Union[str, Any] = { 'configuration_resnet': ['RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ResNetConfig', 'ResNetOnnxConfig'] } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : int = [ 'RESNET_PRETRAINED_MODEL_ARCHIVE_LIST', 'ResNetForImageClassification', 'ResNetModel', 'ResNetPreTrainedModel', 'ResNetBackbone', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : Union[str, Any] = [ 'TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST', 'TFResNetForImageClassification', 'TFResNetModel', 'TFResNetPreTrainedModel', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : Optional[int] = [ '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 _lowercase : Dict = _LazyModule(__name__, globals()['__file__'], _import_structure)
332
1
"""simple docstring""" import functools import operator from ...configuration_utils import PretrainedConfig from ...utils import logging _lowercase : int = logging.get_logger(__name__) _lowercase : List[str] = { 'asapp/sew-d-tiny-100k': 'https://huggingface.co/asapp/sew-d-tiny-100k/resolve/main/config.json', # See all SEW-D models at https://huggingface.co/models?filter=sew-d } class _UpperCAmelCase ( _lowerCAmelCase ): a__ : Tuple = "sew-d" def __init__( self : Union[str, Any] , _lowercase : str=32 , _lowercase : Optional[Any]=7_68 , _lowercase : Optional[Any]=12 , _lowercase : Union[str, Any]=12 , _lowercase : List[str]=30_72 , _lowercase : Optional[Any]=2 , _lowercase : str=5_12 , _lowercase : Union[str, Any]=2_56 , _lowercase : Union[str, Any]=True , _lowercase : List[str]=True , _lowercase : Optional[Any]=("p2c", "c2p") , _lowercase : List[Any]="layer_norm" , _lowercase : Any="gelu_python" , _lowercase : Optional[Any]=0.1 , _lowercase : int=0.1 , _lowercase : Dict=0.1 , _lowercase : Tuple=0.0 , _lowercase : str=0.1 , _lowercase : Optional[Any]=0.02 , _lowercase : List[str]=1E-7 , _lowercase : Optional[int]=1E-5 , _lowercase : List[str]="group" , _lowercase : str="gelu" , _lowercase : Tuple=(64, 1_28, 1_28, 1_28, 1_28, 2_56, 2_56, 2_56, 2_56, 5_12, 5_12, 5_12, 5_12) , _lowercase : List[str]=(5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1) , _lowercase : Tuple=(10, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1) , _lowercase : Dict=False , _lowercase : Any=1_28 , _lowercase : Optional[Any]=16 , _lowercase : List[Any]=True , _lowercase : List[Any]=0.05 , _lowercase : Optional[Any]=10 , _lowercase : Optional[int]=2 , _lowercase : Optional[Any]=0.0 , _lowercase : Any=10 , _lowercase : Optional[int]=0 , _lowercase : Any="mean" , _lowercase : Tuple=False , _lowercase : Any=False , _lowercase : str=2_56 , _lowercase : Tuple=0 , _lowercase : Optional[int]=1 , _lowercase : str=2 , **_lowercase : Optional[Any] , ): super().__init__(**_lowercase , pad_token_id=_lowercase , bos_token_id=_lowercase , eos_token_id=_lowercase ) __UpperCAmelCase = hidden_size __UpperCAmelCase = feat_extract_norm __UpperCAmelCase = feat_extract_activation __UpperCAmelCase = list(_lowercase ) __UpperCAmelCase = list(_lowercase ) __UpperCAmelCase = list(_lowercase ) __UpperCAmelCase = conv_bias __UpperCAmelCase = num_conv_pos_embeddings __UpperCAmelCase = num_conv_pos_embedding_groups __UpperCAmelCase = len(self.conv_dim ) __UpperCAmelCase = num_hidden_layers __UpperCAmelCase = intermediate_size __UpperCAmelCase = squeeze_factor __UpperCAmelCase = max_position_embeddings __UpperCAmelCase = position_buckets __UpperCAmelCase = share_att_key __UpperCAmelCase = relative_attention __UpperCAmelCase = norm_rel_ebd __UpperCAmelCase = list(_lowercase ) __UpperCAmelCase = hidden_act __UpperCAmelCase = num_attention_heads __UpperCAmelCase = hidden_dropout __UpperCAmelCase = attention_dropout __UpperCAmelCase = activation_dropout __UpperCAmelCase = feat_proj_dropout __UpperCAmelCase = final_dropout __UpperCAmelCase = layer_norm_eps __UpperCAmelCase = feature_layer_norm_eps __UpperCAmelCase = initializer_range __UpperCAmelCase = vocab_size if ( (len(self.conv_stride ) != self.num_feat_extract_layers) or (len(self.conv_kernel ) != self.num_feat_extract_layers) or (len(self.conv_dim ) != self.num_feat_extract_layers) ): raise ValueError( '''Configuration for convolutional layers is incorrect.''' '''It is required that `len(config.conv_dim)` == `len(config.conv_stride)` == `len(config.conv_kernel)`,''' F'''but is `len(config.conv_dim) = {len(self.conv_dim )}`, `len(config.conv_stride)''' F'''= {len(self.conv_stride )}`, `len(config.conv_kernel) = {len(self.conv_kernel )}`.''' ) # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779 __UpperCAmelCase = apply_spec_augment __UpperCAmelCase = mask_time_prob __UpperCAmelCase = mask_time_length __UpperCAmelCase = mask_time_min_masks __UpperCAmelCase = mask_feature_prob __UpperCAmelCase = mask_feature_length __UpperCAmelCase = mask_feature_min_masks # ctc loss __UpperCAmelCase = ctc_loss_reduction __UpperCAmelCase = ctc_zero_infinity # sequence classification __UpperCAmelCase = use_weighted_layer_sum __UpperCAmelCase = classifier_proj_size @property def a ( self : int ): return functools.reduce(operator.mul , self.conv_stride , 1 )
332
"""simple docstring""" _lowercase : Any = '\n# Installazione di Transformers\n! pip install transformers datasets\n# Per installare dalla fonte invece dell\'ultima versione rilasciata, commenta il comando sopra e\n# rimuovi la modalità commento al comando seguente.\n# ! pip install git+https://github.com/huggingface/transformers.git\n' _lowercase : Tuple = [{'type': 'code', 'content': INSTALL_CONTENT}] _lowercase : int = { '{processor_class}': 'FakeProcessorClass', '{model_class}': 'FakeModelClass', '{object_class}': 'FakeObjectClass', }
332
1
"""simple docstring""" import warnings from contextlib import contextmanager from ...processing_utils import ProcessorMixin class _UpperCAmelCase ( _lowerCAmelCase ): a__ : List[str] = "Speech2TextFeatureExtractor" a__ : Optional[Any] = "Speech2TextTokenizer" def __init__( self : Union[str, Any] , _lowercase : int , _lowercase : Any ): super().__init__(_lowercase , _lowercase ) __UpperCAmelCase = self.feature_extractor __UpperCAmelCase = False def __call__( self : Union[str, Any] , *_lowercase : Dict , **_lowercase : Tuple ): # For backward compatibility if self._in_target_context_manager: return self.current_processor(*_lowercase , **_lowercase ) if "raw_speech" in kwargs: warnings.warn('''Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead.''' ) __UpperCAmelCase = kwargs.pop('''raw_speech''' ) else: __UpperCAmelCase = kwargs.pop('''audio''' , _lowercase ) __UpperCAmelCase = kwargs.pop('''sampling_rate''' , _lowercase ) __UpperCAmelCase = kwargs.pop('''text''' , _lowercase ) if len(_lowercase ) > 0: __UpperCAmelCase = args[0] __UpperCAmelCase = args[1:] if audio is None and text is None: raise ValueError('''You need to specify either an `audio` or `text` input to process.''' ) if audio is not None: __UpperCAmelCase = self.feature_extractor(_lowercase , *_lowercase , sampling_rate=_lowercase , **_lowercase ) if text is not None: __UpperCAmelCase = self.tokenizer(_lowercase , **_lowercase ) if text is None: return inputs elif audio is None: return encodings else: __UpperCAmelCase = encodings['''input_ids'''] return inputs def a ( self : Optional[Any] , *_lowercase : str , **_lowercase : Optional[int] ): return self.tokenizer.batch_decode(*_lowercase , **_lowercase ) def a ( self : Union[str, Any] , *_lowercase : Any , **_lowercase : int ): return self.tokenizer.decode(*_lowercase , **_lowercase ) @contextmanager def a ( self : List[str] ): warnings.warn( '''`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your ''' '''labels by using the argument `text` of the regular `__call__` method (either in the same call as ''' '''your audio inputs, or in a separate call.''' ) __UpperCAmelCase = True __UpperCAmelCase = self.tokenizer yield __UpperCAmelCase = self.feature_extractor __UpperCAmelCase = False
332
"""simple docstring""" import importlib.util import os import platform from argparse import ArgumentParser import huggingface_hub from .. import __version__ as version from ..utils import ( is_accelerate_available, is_flax_available, is_safetensors_available, is_tf_available, is_torch_available, ) from . import BaseTransformersCLICommand def lowercase__ ( snake_case_ :Optional[int] ): return EnvironmentCommand() def lowercase__ ( snake_case_ :List[str] ): return EnvironmentCommand(args.accelerate_config_file ) class _UpperCAmelCase ( _lowerCAmelCase ): @staticmethod def a ( _lowercase : ArgumentParser ): __UpperCAmelCase = parser.add_parser('''env''' ) download_parser.set_defaults(func=_lowercase ) download_parser.add_argument( '''--accelerate-config_file''' , default=_lowercase , help='''The accelerate config file to use for the default values in the launching script.''' , ) download_parser.set_defaults(func=_lowercase ) def __init__( self : Optional[int] , _lowercase : str , *_lowercase : Tuple ): __UpperCAmelCase = accelerate_config_file def a ( self : Dict ): __UpperCAmelCase = '''not installed''' if is_safetensors_available(): import safetensors __UpperCAmelCase = safetensors.__version__ elif importlib.util.find_spec('''safetensors''' ) is not None: import safetensors __UpperCAmelCase = F'''{safetensors.__version__} but is ignored because of PyTorch version too old.''' __UpperCAmelCase = '''not installed''' __UpperCAmelCase = __UpperCAmelCase = '''not found''' if is_accelerate_available(): import accelerate from accelerate.commands.config import default_config_file, load_config_from_file __UpperCAmelCase = accelerate.__version__ # Get the default from the config file. if self._accelerate_config_file is not None or os.path.isfile(_lowercase ): __UpperCAmelCase = load_config_from_file(self._accelerate_config_file ).to_dict() __UpperCAmelCase = ( '''\n'''.join([F'''\t- {prop}: {val}''' for prop, val in accelerate_config.items()] ) if isinstance(_lowercase , _lowercase ) else F'''\t{accelerate_config}''' ) __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''NA''' if is_torch_available(): import torch __UpperCAmelCase = torch.__version__ __UpperCAmelCase = torch.cuda.is_available() __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''NA''' if is_tf_available(): import tensorflow as tf __UpperCAmelCase = tf.__version__ try: # deprecated in v2.1 __UpperCAmelCase = tf.test.is_gpu_available() except AttributeError: # returns list of devices, convert to bool __UpperCAmelCase = bool(tf.config.list_physical_devices('''GPU''' ) ) __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''NA''' if is_flax_available(): import flax import jax import jaxlib __UpperCAmelCase = flax.__version__ __UpperCAmelCase = jax.__version__ __UpperCAmelCase = jaxlib.__version__ __UpperCAmelCase = jax.lib.xla_bridge.get_backend().platform __UpperCAmelCase = { '''`transformers` version''': version, '''Platform''': platform.platform(), '''Python version''': platform.python_version(), '''Huggingface_hub version''': huggingface_hub.__version__, '''Safetensors version''': F'''{safetensors_version}''', '''Accelerate version''': F'''{accelerate_version}''', '''Accelerate config''': F'''{accelerate_config_str}''', '''PyTorch version (GPU?)''': F'''{pt_version} ({pt_cuda_available})''', '''Tensorflow version (GPU?)''': F'''{tf_version} ({tf_cuda_available})''', '''Flax version (CPU?/GPU?/TPU?)''': F'''{flax_version} ({jax_backend})''', '''Jax version''': F'''{jax_version}''', '''JaxLib version''': F'''{jaxlib_version}''', '''Using GPU in script?''': '''<fill in>''', '''Using distributed or parallel set-up in script?''': '''<fill in>''', } print('''\nCopy-and-paste the text below in your GitHub issue and FILL OUT the two last points.\n''' ) print(self.format_dict(_lowercase ) ) return info @staticmethod def a ( _lowercase : str ): return "\n".join([F'''- {prop}: {val}''' for prop, val in d.items()] ) + "\n"
332
1
"""simple docstring""" import os from pathlib import Path import numpy as np import pytest from pack_dataset import pack_data_dir from parameterized import parameterized from save_len_file import save_len_file from torch.utils.data import DataLoader from transformers import AutoTokenizer from transformers.models.mbart.modeling_mbart import shift_tokens_right from transformers.testing_utils import TestCasePlus, slow from utils import FAIRSEQ_AVAILABLE, DistributedSortishSampler, LegacySeqaSeqDataset, SeqaSeqDataset _lowercase : str = 'bert-base-cased' _lowercase : Any = 'google/pegasus-xsum' _lowercase : Any = [' Sam ate lunch today.', 'Sams lunch ingredients.'] _lowercase : List[str] = ['A very interesting story about what I ate for lunch.', 'Avocado, celery, turkey, coffee'] _lowercase : Any = 'patrickvonplaten/t5-tiny-random' _lowercase : str = 'sshleifer/bart-tiny-random' _lowercase : Dict = 'sshleifer/tiny-mbart' _lowercase : Dict = 'sshleifer/tiny-marian-en-de' def lowercase__ ( snake_case_ :Path , snake_case_ :list ): __UpperCAmelCase = '''\n'''.join(snake_case_ ) Path(snake_case_ ).open('''w''' ).writelines(snake_case_ ) def lowercase__ ( snake_case_ :Any ): for split in ["train", "val", "test"]: _dump_articles(os.path.join(snake_case_ , F'''{split}.source''' ) , snake_case_ ) _dump_articles(os.path.join(snake_case_ , F'''{split}.target''' ) , snake_case_ ) return tmp_dir class _UpperCAmelCase ( _lowerCAmelCase ): @parameterized.expand( [ MBART_TINY, MARIAN_TINY, T5_TINY, BART_TINY, PEGASUS_XSUM, ] , ) @slow def a ( self : List[str] , _lowercase : Dict ): __UpperCAmelCase = AutoTokenizer.from_pretrained(_lowercase ) __UpperCAmelCase = make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir() ) __UpperCAmelCase = max(len(tokenizer.encode(_lowercase ) ) for a in ARTICLES ) __UpperCAmelCase = max(len(tokenizer.encode(_lowercase ) ) for a in SUMMARIES ) __UpperCAmelCase = 4 __UpperCAmelCase = 8 assert max_len_target > max_src_len # Will be truncated assert max_len_source > max_src_len # Will be truncated __UpperCAmelCase , __UpperCAmelCase = '''ro_RO''', '''de_DE''' # ignored for all but mbart, but never causes error. __UpperCAmelCase = SeqaSeqDataset( _lowercase , data_dir=_lowercase , type_path='''train''' , max_source_length=_lowercase , max_target_length=_lowercase , src_lang=_lowercase , tgt_lang=_lowercase , ) __UpperCAmelCase = DataLoader(_lowercase , batch_size=2 , collate_fn=train_dataset.collate_fn ) for batch in dataloader: assert isinstance(_lowercase , _lowercase ) assert batch["attention_mask"].shape == batch["input_ids"].shape # show that articles were trimmed. assert batch["input_ids"].shape[1] == max_src_len # show that targets are the same len assert batch["labels"].shape[1] == max_tgt_len if tok_name != MBART_TINY: continue # check language codes in correct place __UpperCAmelCase = shift_tokens_right(batch['''labels'''] , tokenizer.pad_token_id ) assert batch["decoder_input_ids"][0, 0].item() == tokenizer.lang_code_to_id[tgt_lang] assert batch["decoder_input_ids"][0, -1].item() == tokenizer.eos_token_id assert batch["input_ids"][0, -2].item() == tokenizer.eos_token_id assert batch["input_ids"][0, -1].item() == tokenizer.lang_code_to_id[src_lang] break # No need to test every batch @parameterized.expand([BART_TINY, BERT_BASE_CASED] ) def a ( self : List[str] , _lowercase : str ): __UpperCAmelCase = AutoTokenizer.from_pretrained(_lowercase ) __UpperCAmelCase = make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir() ) __UpperCAmelCase = max(len(tokenizer.encode(_lowercase ) ) for a in ARTICLES ) __UpperCAmelCase = max(len(tokenizer.encode(_lowercase ) ) for a in SUMMARIES ) __UpperCAmelCase = 4 __UpperCAmelCase = LegacySeqaSeqDataset( _lowercase , data_dir=_lowercase , type_path='''train''' , max_source_length=20 , max_target_length=_lowercase , ) __UpperCAmelCase = DataLoader(_lowercase , batch_size=2 , collate_fn=train_dataset.collate_fn ) for batch in dataloader: assert batch["attention_mask"].shape == batch["input_ids"].shape # show that articles were trimmed. assert batch["input_ids"].shape[1] == max_len_source assert 20 >= batch["input_ids"].shape[1] # trimmed significantly # show that targets were truncated assert batch["labels"].shape[1] == trunc_target # Truncated assert max_len_target > trunc_target # Truncated break # No need to test every batch def a ( self : List[Any] ): __UpperCAmelCase = AutoTokenizer.from_pretrained('''facebook/mbart-large-cc25''' ) __UpperCAmelCase = Path(make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir() ) ) __UpperCAmelCase = tmp_dir.joinpath('''train.source''' ).open().readlines() __UpperCAmelCase = Path(make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir() ) ) pack_data_dir(_lowercase , _lowercase , 1_28 , _lowercase ) __UpperCAmelCase = {x.name for x in tmp_dir.iterdir()} __UpperCAmelCase = {x.name for x in save_dir.iterdir()} __UpperCAmelCase = save_dir.joinpath('''train.source''' ).open().readlines() # orig: [' Sam ate lunch today.\n', 'Sams lunch ingredients.'] # desired_packed: [' Sam ate lunch today.\n Sams lunch ingredients.'] assert len(_lowercase ) < len(_lowercase ) assert len(_lowercase ) == 1 assert len(packed_examples[0] ) == sum(len(_lowercase ) for x in orig_examples ) assert orig_paths == new_paths @pytest.mark.skipif(not FAIRSEQ_AVAILABLE , reason='''This test requires fairseq''' ) def a ( self : Optional[Any] ): if not FAIRSEQ_AVAILABLE: return __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase = self._get_dataset(max_len=64 ) __UpperCAmelCase = 64 __UpperCAmelCase = ds.make_dynamic_sampler(_lowercase , required_batch_size_multiple=_lowercase ) __UpperCAmelCase = [len(_lowercase ) for x in batch_sampler] assert len(set(_lowercase ) ) > 1 # it's not dynamic batch size if every batch is the same length assert sum(_lowercase ) == len(_lowercase ) # no dropped or added examples __UpperCAmelCase = DataLoader(_lowercase , batch_sampler=_lowercase , collate_fn=ds.collate_fn , num_workers=2 ) __UpperCAmelCase = [] __UpperCAmelCase = [] for batch in data_loader: __UpperCAmelCase = batch['''input_ids'''].shape __UpperCAmelCase = src_shape[0] assert bs % required_batch_size_multiple == 0 or bs < required_batch_size_multiple __UpperCAmelCase = np.product(batch['''input_ids'''].shape ) num_src_per_batch.append(_lowercase ) if num_src_tokens > (max_tokens * 1.1): failures.append(_lowercase ) assert num_src_per_batch[0] == max(_lowercase ) if failures: raise AssertionError(F'''too many tokens in {len(_lowercase )} batches''' ) def a ( self : Optional[Any] ): __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase = self._get_dataset(max_len=5_12 ) __UpperCAmelCase = 2 __UpperCAmelCase = ds.make_sortish_sampler(_lowercase , shuffle=_lowercase ) __UpperCAmelCase = DataLoader(_lowercase , batch_size=_lowercase , collate_fn=ds.collate_fn , num_workers=2 ) __UpperCAmelCase = DataLoader(_lowercase , batch_size=_lowercase , collate_fn=ds.collate_fn , num_workers=2 , sampler=_lowercase ) __UpperCAmelCase = tokenizer.pad_token_id def count_pad_tokens(_lowercase : Optional[Any] , _lowercase : Optional[Any]="input_ids" ): return [batch[k].eq(_lowercase ).sum().item() for batch in data_loader] assert sum(count_pad_tokens(_lowercase , k='''labels''' ) ) < sum(count_pad_tokens(_lowercase , k='''labels''' ) ) assert sum(count_pad_tokens(_lowercase ) ) < sum(count_pad_tokens(_lowercase ) ) assert len(_lowercase ) == len(_lowercase ) def a ( self : Dict , _lowercase : int=10_00 , _lowercase : Any=1_28 ): if os.getenv('''USE_REAL_DATA''' , _lowercase ): __UpperCAmelCase = '''examples/seq2seq/wmt_en_ro''' __UpperCAmelCase = max_len * 2 * 64 if not Path(_lowercase ).joinpath('''train.len''' ).exists(): save_len_file(_lowercase , _lowercase ) else: __UpperCAmelCase = '''examples/seq2seq/test_data/wmt_en_ro''' __UpperCAmelCase = max_len * 4 save_len_file(_lowercase , _lowercase ) __UpperCAmelCase = AutoTokenizer.from_pretrained(_lowercase ) __UpperCAmelCase = SeqaSeqDataset( _lowercase , data_dir=_lowercase , type_path='''train''' , max_source_length=_lowercase , max_target_length=_lowercase , n_obs=_lowercase , ) return ds, max_tokens, tokenizer def a ( self : List[str] ): __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase = self._get_dataset() __UpperCAmelCase = set(DistributedSortishSampler(_lowercase , 2_56 , num_replicas=2 , rank=0 , add_extra_examples=_lowercase ) ) __UpperCAmelCase = set(DistributedSortishSampler(_lowercase , 2_56 , num_replicas=2 , rank=1 , add_extra_examples=_lowercase ) ) assert idsa.intersection(_lowercase ) == set() @parameterized.expand( [ MBART_TINY, MARIAN_TINY, T5_TINY, BART_TINY, PEGASUS_XSUM, ] , ) def a ( self : Union[str, Any] , _lowercase : str ): __UpperCAmelCase = AutoTokenizer.from_pretrained(_lowercase , use_fast=_lowercase ) if tok_name == MBART_TINY: __UpperCAmelCase = SeqaSeqDataset( _lowercase , data_dir=make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir() ) , type_path='''train''' , max_source_length=4 , max_target_length=8 , src_lang='''EN''' , tgt_lang='''FR''' , ) __UpperCAmelCase = train_dataset.dataset_kwargs assert "src_lang" in kwargs and "tgt_lang" in kwargs else: __UpperCAmelCase = SeqaSeqDataset( _lowercase , data_dir=make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir() ) , type_path='''train''' , max_source_length=4 , max_target_length=8 , ) __UpperCAmelCase = train_dataset.dataset_kwargs assert "add_prefix_space" not in kwargs if tok_name != BART_TINY else "add_prefix_space" in kwargs assert len(_lowercase ) == 1 if tok_name == BART_TINY else len(_lowercase ) == 0
332
"""simple docstring""" from __future__ import annotations def lowercase__ ( snake_case_ :list[float] , snake_case_ :list[float] ): __UpperCAmelCase = sorted(numsa + numsa ) __UpperCAmelCase , __UpperCAmelCase = divmod(len(snake_case_ ) , 2 ) if mod == 1: return all_numbers[div] else: return (all_numbers[div] + all_numbers[div - 1]) / 2 if __name__ == "__main__": import doctest doctest.testmod() _lowercase : int = [float(x) for x in input('Enter the elements of first array: ').split()] _lowercase : Tuple = [float(x) for x in input('Enter the elements of second array: ').split()] print(f"""The median of two arrays is: {median_of_two_arrays(array_a, array_a)}""")
332
1
"""simple docstring""" import functools import operator from ...configuration_utils import PretrainedConfig from ...utils import logging _lowercase : Union[str, Any] = logging.get_logger(__name__) _lowercase : int = { 'asapp/sew-tiny-100k': 'https://huggingface.co/asapp/sew-tiny-100k/resolve/main/config.json', # See all SEW models at https://huggingface.co/models?filter=sew } class _UpperCAmelCase ( _lowerCAmelCase ): a__ : Optional[int] = "sew" def __init__( self : Union[str, Any] , _lowercase : Any=32 , _lowercase : Dict=7_68 , _lowercase : Dict=12 , _lowercase : Dict=12 , _lowercase : List[Any]=30_72 , _lowercase : Tuple=2 , _lowercase : List[str]="gelu" , _lowercase : Optional[Any]=0.1 , _lowercase : List[Any]=0.1 , _lowercase : List[str]=0.1 , _lowercase : List[str]=0.0 , _lowercase : int=0.1 , _lowercase : Union[str, Any]=0.1 , _lowercase : List[str]=0.02 , _lowercase : Optional[Any]=1E-5 , _lowercase : Tuple="group" , _lowercase : Optional[Any]="gelu" , _lowercase : Dict=(64, 1_28, 1_28, 1_28, 1_28, 2_56, 2_56, 2_56, 2_56, 5_12, 5_12, 5_12, 5_12) , _lowercase : Union[str, Any]=(5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1) , _lowercase : Dict=(10, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1) , _lowercase : str=False , _lowercase : Optional[int]=1_28 , _lowercase : List[Any]=16 , _lowercase : str=True , _lowercase : str=0.05 , _lowercase : int=10 , _lowercase : List[Any]=2 , _lowercase : str=0.0 , _lowercase : str=10 , _lowercase : int=0 , _lowercase : int="mean" , _lowercase : str=False , _lowercase : Optional[Any]=False , _lowercase : Optional[Any]=2_56 , _lowercase : int=0 , _lowercase : Tuple=1 , _lowercase : Dict=2 , **_lowercase : Any , ): super().__init__(**_lowercase , pad_token_id=_lowercase , bos_token_id=_lowercase , eos_token_id=_lowercase ) __UpperCAmelCase = hidden_size __UpperCAmelCase = feat_extract_norm __UpperCAmelCase = feat_extract_activation __UpperCAmelCase = list(_lowercase ) __UpperCAmelCase = list(_lowercase ) __UpperCAmelCase = list(_lowercase ) __UpperCAmelCase = conv_bias __UpperCAmelCase = num_conv_pos_embeddings __UpperCAmelCase = num_conv_pos_embedding_groups __UpperCAmelCase = len(self.conv_dim ) __UpperCAmelCase = num_hidden_layers __UpperCAmelCase = intermediate_size __UpperCAmelCase = squeeze_factor __UpperCAmelCase = hidden_act __UpperCAmelCase = num_attention_heads __UpperCAmelCase = hidden_dropout __UpperCAmelCase = attention_dropout __UpperCAmelCase = activation_dropout __UpperCAmelCase = feat_proj_dropout __UpperCAmelCase = final_dropout __UpperCAmelCase = layerdrop __UpperCAmelCase = layer_norm_eps __UpperCAmelCase = initializer_range __UpperCAmelCase = vocab_size if ( (len(self.conv_stride ) != self.num_feat_extract_layers) or (len(self.conv_kernel ) != self.num_feat_extract_layers) or (len(self.conv_dim ) != self.num_feat_extract_layers) ): raise ValueError( '''Configuration for convolutional layers is incorrect.''' '''It is required that `len(config.conv_dim)` == `len(config.conv_stride)` == `len(config.conv_kernel)`,''' F'''but is `len(config.conv_dim) = {len(self.conv_dim )}`, `len(config.conv_stride)''' F'''= {len(self.conv_stride )}`, `len(config.conv_kernel) = {len(self.conv_kernel )}`.''' ) # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779 __UpperCAmelCase = apply_spec_augment __UpperCAmelCase = mask_time_prob __UpperCAmelCase = mask_time_length __UpperCAmelCase = mask_time_min_masks __UpperCAmelCase = mask_feature_prob __UpperCAmelCase = mask_feature_length __UpperCAmelCase = mask_feature_min_masks # ctc loss __UpperCAmelCase = ctc_loss_reduction __UpperCAmelCase = ctc_zero_infinity # sequence classification __UpperCAmelCase = use_weighted_layer_sum __UpperCAmelCase = classifier_proj_size @property def a ( self : int ): return functools.reduce(operator.mul , self.conv_stride , 1 )
332
"""simple docstring""" import heapq as hq import math from collections.abc import Iterator class _UpperCAmelCase : def __init__( self : Union[str, Any] , _lowercase : Optional[Any] ): __UpperCAmelCase = str(id_ ) __UpperCAmelCase = None __UpperCAmelCase = None __UpperCAmelCase = [] __UpperCAmelCase = {} # {vertex:distance} def __lt__( self : str , _lowercase : List[Any] ): return self.key < other.key def __repr__( self : int ): return self.id def a ( self : Union[str, Any] , _lowercase : int ): self.neighbors.append(_lowercase ) def a ( self : List[Any] , _lowercase : Optional[Any] , _lowercase : int ): __UpperCAmelCase = weight def lowercase__ ( snake_case_ :int , snake_case_ :Any , snake_case_ :Union[str, Any] , snake_case_ :List[str] ): # add the neighbors: graph[a - 1].add_neighbor(graph[b - 1] ) graph[b - 1].add_neighbor(graph[a - 1] ) # add the edges: graph[a - 1].add_edge(graph[b - 1] , snake_case_ ) graph[b - 1].add_edge(graph[a - 1] , snake_case_ ) def lowercase__ ( snake_case_ :list , snake_case_ :Vertex ): __UpperCAmelCase = [] for u in graph: __UpperCAmelCase = math.inf __UpperCAmelCase = None __UpperCAmelCase = 0 __UpperCAmelCase = graph[:] while q: __UpperCAmelCase = min(snake_case_ ) q.remove(snake_case_ ) for v in u.neighbors: if (v in q) and (u.edges[v.id] < v.key): __UpperCAmelCase = u __UpperCAmelCase = u.edges[v.id] for i in range(1 , len(snake_case_ ) ): a.append((int(graph[i].id ) + 1, int(graph[i].pi.id ) + 1) ) return a def lowercase__ ( snake_case_ :list , snake_case_ :Vertex ): for u in graph: __UpperCAmelCase = math.inf __UpperCAmelCase = None __UpperCAmelCase = 0 __UpperCAmelCase = list(snake_case_ ) hq.heapify(snake_case_ ) while h: __UpperCAmelCase = hq.heappop(snake_case_ ) for v in u.neighbors: if (v in h) and (u.edges[v.id] < v.key): __UpperCAmelCase = u __UpperCAmelCase = u.edges[v.id] hq.heapify(snake_case_ ) for i in range(1 , len(snake_case_ ) ): yield (int(graph[i].id ) + 1, int(graph[i].pi.id ) + 1) def lowercase__ ( ): pass if __name__ == "__main__": import doctest doctest.testmod()
332
1
"""simple docstring""" import unittest from huggingface_hub import hf_hub_download from transformers import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING, VideoMAEFeatureExtractor from transformers.pipelines import VideoClassificationPipeline, pipeline from transformers.testing_utils import ( is_pipeline_test, nested_simplify, require_decord, require_tf, require_torch, require_torch_or_tf, require_vision, ) from .test_pipelines_common import ANY @is_pipeline_test @require_torch_or_tf @require_vision @require_decord class _UpperCAmelCase ( unittest.TestCase ): a__ : List[Any] = MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING def a ( self : int , _lowercase : int , _lowercase : List[str] , _lowercase : Union[str, Any] ): __UpperCAmelCase = hf_hub_download( repo_id='''nateraw/video-demo''' , filename='''archery.mp4''' , repo_type='''dataset''' ) __UpperCAmelCase = VideoClassificationPipeline(model=_lowercase , image_processor=_lowercase , top_k=2 ) __UpperCAmelCase = [ example_video_filepath, '''https://huggingface.co/datasets/nateraw/video-demo/resolve/main/archery.mp4''', ] return video_classifier, examples def a ( self : List[Any] , _lowercase : Any , _lowercase : Dict ): for example in examples: __UpperCAmelCase = video_classifier(_lowercase ) self.assertEqual( _lowercase , [ {'''score''': ANY(_lowercase ), '''label''': ANY(_lowercase )}, {'''score''': ANY(_lowercase ), '''label''': ANY(_lowercase )}, ] , ) @require_torch def a ( self : Any ): __UpperCAmelCase = '''hf-internal-testing/tiny-random-VideoMAEForVideoClassification''' __UpperCAmelCase = VideoMAEFeatureExtractor( size={'''shortest_edge''': 10} , crop_size={'''height''': 10, '''width''': 10} ) __UpperCAmelCase = pipeline( '''video-classification''' , model=_lowercase , feature_extractor=_lowercase , frame_sampling_rate=4 ) __UpperCAmelCase = hf_hub_download(repo_id='''nateraw/video-demo''' , filename='''archery.mp4''' , repo_type='''dataset''' ) __UpperCAmelCase = video_classifier(_lowercase , top_k=2 ) self.assertEqual( nested_simplify(_lowercase , decimals=4 ) , [{'''score''': 0.5_199, '''label''': '''LABEL_0'''}, {'''score''': 0.4_801, '''label''': '''LABEL_1'''}] , ) __UpperCAmelCase = video_classifier( [ video_file_path, video_file_path, ] , top_k=2 , ) self.assertEqual( nested_simplify(_lowercase , decimals=4 ) , [ [{'''score''': 0.5_199, '''label''': '''LABEL_0'''}, {'''score''': 0.4_801, '''label''': '''LABEL_1'''}], [{'''score''': 0.5_199, '''label''': '''LABEL_0'''}, {'''score''': 0.4_801, '''label''': '''LABEL_1'''}], ] , ) @require_tf def a ( self : int ): pass
332
"""simple docstring""" from ...configuration_utils import PretrainedConfig from ...utils import logging _lowercase : str = logging.get_logger(__name__) _lowercase : Dict = { 'microsoft/swinv2-tiny-patch4-window8-256': ( 'https://huggingface.co/microsoft/swinv2-tiny-patch4-window8-256/resolve/main/config.json' ), } class _UpperCAmelCase ( _lowerCAmelCase ): a__ : Tuple = "swinv2" a__ : List[Any] = { "num_attention_heads": "num_heads", "num_hidden_layers": "num_layers", } def __init__( self : Any , _lowercase : List[Any]=2_24 , _lowercase : int=4 , _lowercase : Optional[int]=3 , _lowercase : Optional[Any]=96 , _lowercase : Optional[int]=[2, 2, 6, 2] , _lowercase : Optional[int]=[3, 6, 12, 24] , _lowercase : str=7 , _lowercase : Union[str, Any]=4.0 , _lowercase : List[str]=True , _lowercase : List[Any]=0.0 , _lowercase : Dict=0.0 , _lowercase : List[Any]=0.1 , _lowercase : Union[str, Any]="gelu" , _lowercase : Tuple=False , _lowercase : Optional[int]=0.02 , _lowercase : List[Any]=1E-5 , _lowercase : Tuple=32 , **_lowercase : Optional[int] , ): super().__init__(**_lowercase ) __UpperCAmelCase = image_size __UpperCAmelCase = patch_size __UpperCAmelCase = num_channels __UpperCAmelCase = embed_dim __UpperCAmelCase = depths __UpperCAmelCase = len(_lowercase ) __UpperCAmelCase = num_heads __UpperCAmelCase = window_size __UpperCAmelCase = mlp_ratio __UpperCAmelCase = qkv_bias __UpperCAmelCase = hidden_dropout_prob __UpperCAmelCase = attention_probs_dropout_prob __UpperCAmelCase = drop_path_rate __UpperCAmelCase = hidden_act __UpperCAmelCase = use_absolute_embeddings __UpperCAmelCase = layer_norm_eps __UpperCAmelCase = initializer_range __UpperCAmelCase = encoder_stride # we set the hidden_size attribute in order to make Swinv2 work with VisionEncoderDecoderModel # this indicates the channel dimension after the last stage of the model __UpperCAmelCase = int(embed_dim * 2 ** (len(_lowercase ) - 1) ) __UpperCAmelCase = (0, 0, 0, 0)
332
1
"""simple docstring""" import os import tempfile import unittest from pathlib import Path from transformers import AutoConfig, is_torch_available from transformers.testing_utils import require_torch, torch_device if is_torch_available(): from transformers import PyTorchBenchmark, PyTorchBenchmarkArguments @require_torch class _UpperCAmelCase ( unittest.TestCase ): def a ( self : Dict , _lowercase : Union[str, Any] ): for model_result in results.values(): for batch_size, sequence_length in zip(model_result['''bs'''] , model_result['''ss'''] ): __UpperCAmelCase = model_result['''result'''][batch_size][sequence_length] self.assertIsNotNone(_lowercase ) def a ( self : str ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : List[str] ): __UpperCAmelCase = '''sgugger/tiny-distilbert-classification''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , only_pretrain_model=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : str ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , torchscript=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) @unittest.skipIf(torch_device == '''cpu''' , '''Cant do half precision''' ) def a ( self : Optional[Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , fpaa=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : int ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) # set architectures equal to `None` __UpperCAmelCase = None __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : Tuple ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) @unittest.skipIf(torch_device == '''cpu''' , '''Can\'t do half precision''' ) def a ( self : Optional[Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , fpaa=_lowercase , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) def a ( self : Any ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : str ): __UpperCAmelCase = '''sshleifer/tinier_bart''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : Union[str, Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) def a ( self : int ): __UpperCAmelCase = '''sshleifer/tinier_bart''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) def a ( self : Optional[Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' with tempfile.TemporaryDirectory() as tmp_dir: __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , save_to_csv=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , inference_time_csv_file=os.path.join(_lowercase , '''inf_time.csv''' ) , train_memory_csv_file=os.path.join(_lowercase , '''train_mem.csv''' ) , inference_memory_csv_file=os.path.join(_lowercase , '''inf_mem.csv''' ) , train_time_csv_file=os.path.join(_lowercase , '''train_time.csv''' ) , env_info_csv_file=os.path.join(_lowercase , '''env.csv''' ) , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) benchmark.run() self.assertTrue(Path(os.path.join(_lowercase , '''inf_time.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(_lowercase , '''train_time.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(_lowercase , '''inf_mem.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(_lowercase , '''train_mem.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(_lowercase , '''env.csv''' ) ).exists() ) def a ( self : List[Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' def _check_summary_is_not_empty(_lowercase : str ): self.assertTrue(hasattr(_lowercase , '''sequential''' ) ) self.assertTrue(hasattr(_lowercase , '''cumulative''' ) ) self.assertTrue(hasattr(_lowercase , '''current''' ) ) self.assertTrue(hasattr(_lowercase , '''total''' ) ) with tempfile.TemporaryDirectory() as tmp_dir: __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , log_filename=os.path.join(_lowercase , '''log.txt''' ) , log_print=_lowercase , trace_memory_line_by_line=_lowercase , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() _check_summary_is_not_empty(result.inference_summary ) _check_summary_is_not_empty(result.train_summary ) self.assertTrue(Path(os.path.join(_lowercase , '''log.txt''' ) ).exists() )
332
"""simple docstring""" import pprint import requests _lowercase : Optional[Any] = 'https://zenquotes.io/api' def lowercase__ ( ): return requests.get(API_ENDPOINT_URL + '''/today''' ).json() def lowercase__ ( ): return requests.get(API_ENDPOINT_URL + '''/random''' ).json() if __name__ == "__main__": _lowercase : int = random_quotes() pprint.pprint(response)
332
1
"""simple docstring""" from dataclasses import dataclass, field from typing import ClassVar, Dict from ..features import Features, Value from .base import TaskTemplate @dataclass(frozen=_lowerCAmelCase ) class _UpperCAmelCase ( _lowerCAmelCase ): # `task` is not a ClassVar since we want it to be part of the `asdict` output for JSON serialization a__ : str = field(default="summarization" , metadata={"include_in_asdict_even_if_is_default": True} ) a__ : ClassVar[Features] = Features({"text": Value("string" )} ) a__ : ClassVar[Features] = Features({"summary": Value("string" )} ) a__ : str = "text" a__ : str = "summary" @property def a ( self : Tuple ): return {self.text_column: "text", self.summary_column: "summary"}
332
"""simple docstring""" from typing import List, Optional, Union import numpy as np import tensorflow as tf from .utils import logging _lowercase : List[str] = logging.get_logger(__name__) def lowercase__ ( snake_case_ :Union[tf.Tensor, np.ndarray] ): if isinstance(snake_case_ , np.ndarray ): return list(tensor.shape ) __UpperCAmelCase = tf.shape(snake_case_ ) if tensor.shape == tf.TensorShape(snake_case_ ): return dynamic __UpperCAmelCase = tensor.shape.as_list() return [dynamic[i] if s is None else s for i, s in enumerate(snake_case_ )] def lowercase__ ( snake_case_ :tf.Tensor , snake_case_ :Optional[int] = None , snake_case_ :Optional[str] = None ): return tf.nn.softmax(logits=logits + 1E-9 , axis=snake_case_ , name=snake_case_ ) def lowercase__ ( snake_case_ :int , snake_case_ :Union[str, Any] , snake_case_ :str , snake_case_ :Union[str, Any]=1E-5 , snake_case_ :List[str]=-1 ): # This is a very simplified functional layernorm, designed to duplicate # the functionality of PyTorch nn.functional.layer_norm when this is needed to port # models in Transformers. if weight.shape.rank != 1 or bias.shape.rank != 1 or not isinstance(snake_case_ , snake_case_ ): raise NotImplementedError('''Only 1D weight and bias tensors are supported for now, with only a single axis.''' ) # Get mean and variance on the axis to be normalized __UpperCAmelCase , __UpperCAmelCase = tf.nn.moments(snake_case_ , axes=[axis] , keepdims=snake_case_ ) if axis != -1: # Reshape scale and weight to have the same rank as inputs, but with 1 dimensions # on every dimension except axis __UpperCAmelCase = [1] * inputs.shape.rank __UpperCAmelCase = shape_list(snake_case_ )[axis] __UpperCAmelCase = tf.reshape(snake_case_ , snake_case_ ) __UpperCAmelCase = tf.reshape(snake_case_ , snake_case_ ) # Compute layer normalization using the batch_normalization # function. __UpperCAmelCase = tf.nn.batch_normalization( snake_case_ , snake_case_ , snake_case_ , offset=snake_case_ , scale=snake_case_ , variance_epsilon=snake_case_ , ) return outputs def lowercase__ ( snake_case_ :Optional[int] , snake_case_ :List[str]=0 , snake_case_ :Optional[Any]=-1 ): # Replicates the behavior of torch.flatten in TF # If end_dim or start_dim is negative, count them from the end if end_dim < 0: end_dim += input.shape.rank if start_dim < 0: start_dim += input.shape.rank if start_dim == end_dim: return input __UpperCAmelCase = tf.shape(snake_case_ ) __UpperCAmelCase = tf.math.reduce_prod(in_shape[start_dim : end_dim + 1] ) __UpperCAmelCase = tf.concat([in_shape[:start_dim], [flattened_dim], in_shape[end_dim + 1 :]] , axis=0 ) return tf.reshape(snake_case_ , snake_case_ ) def lowercase__ ( snake_case_ :tf.Tensor ): if not isinstance(snake_case_ , tf.Tensor ): __UpperCAmelCase = tf.convert_to_tensor(snake_case_ ) # Catches stray NumPy inputs if encoder_attention_mask.shape.rank == 3: __UpperCAmelCase = encoder_attention_mask[:, None, :, :] if encoder_attention_mask.shape.rank == 2: __UpperCAmelCase = encoder_attention_mask[:, None, None, :] # T5 has a mask that can compare sequence ids, we can simulate this here with this transposition # Cf. https://github.com/tensorflow/mesh/blob/8d2465e9bc93129b913b5ccc6a59aa97abd96ec6/mesh_tensorflow # /transformer/transformer_layers.py#L270 # encoder_extended_attention_mask = (encoder_extended_attention_mask == # encoder_extended_attention_mask.transpose(-1, -2)) __UpperCAmelCase = ( tf.cast(1 , encoder_attention_mask.dtype ) - encoder_extended_attention_mask ) * encoder_extended_attention_mask.dtype.min return encoder_extended_attention_mask def lowercase__ ( snake_case_ :tf.Tensor , snake_case_ :int , snake_case_ :str = "input_ids" ): tf.debugging.assert_less( snake_case_ , tf.cast(snake_case_ , dtype=tensor.dtype ) , message=( F'''The maximum value of {tensor_name} ({tf.math.reduce_max(snake_case_ )}) must be smaller than the embedding ''' F'''layer\'s input dimension ({embed_dim}). The likely cause is some problem at tokenization time.''' ) , ) def lowercase__ ( snake_case_ :List[Any] , snake_case_ :List[Any] , snake_case_ :List[str] ): __UpperCAmelCase = 64_512 # Check that no item in `data` is larger than `HDF5_OBJECT_HEADER_LIMIT` # because in that case even chunking the array would not make the saving # possible. __UpperCAmelCase = [x for x in data if len(snake_case_ ) > HDF5_OBJECT_HEADER_LIMIT] # Expecting this to never be true. if bad_attributes: raise RuntimeError( '''The following attributes cannot be saved to HDF5 file because ''' F'''they are larger than {HDF5_OBJECT_HEADER_LIMIT} ''' F'''bytes: {bad_attributes}''' ) __UpperCAmelCase = np.asarray(snake_case_ ) __UpperCAmelCase = 1 __UpperCAmelCase = np.array_split(snake_case_ , snake_case_ ) # This will never loop forever thanks to the test above. while any(x.nbytes > HDF5_OBJECT_HEADER_LIMIT for x in chunked_data ): num_chunks += 1 __UpperCAmelCase = np.array_split(snake_case_ , snake_case_ ) if num_chunks > 1: for chunk_id, chunk_data in enumerate(snake_case_ ): __UpperCAmelCase = chunk_data else: __UpperCAmelCase = data def lowercase__ ( snake_case_ :str , snake_case_ :List[str] ): if name in group.attrs: __UpperCAmelCase = [n.decode('''utf8''' ) if hasattr(snake_case_ , '''decode''' ) else n for n in group.attrs[name]] else: __UpperCAmelCase = [] __UpperCAmelCase = 0 while "%s%d" % (name, chunk_id) in group.attrs: data.extend( [n.decode('''utf8''' ) if hasattr(snake_case_ , '''decode''' ) else n for n in group.attrs['''%s%d''' % (name, chunk_id)]] ) chunk_id += 1 return data def lowercase__ ( snake_case_ :Tuple ): def _expand_single_ad_tensor(snake_case_ :Optional[int] ): if isinstance(snake_case_ , tf.Tensor ) and t.shape.rank == 1: return tf.expand_dims(snake_case_ , axis=-1 ) return t return tf.nest.map_structure(_expand_single_ad_tensor , snake_case_ )
332
1
"""simple docstring""" from __future__ import annotations def lowercase__ ( snake_case_ :list[int | float] , snake_case_ :int , snake_case_ :int ): if len(snake_case_ ) == 0: raise ValueError('''find_max() arg is an empty sequence''' ) if ( left >= len(snake_case_ ) or left < -len(snake_case_ ) or right >= len(snake_case_ ) or right < -len(snake_case_ ) ): raise IndexError('''list index out of range''' ) if left == right: return nums[left] __UpperCAmelCase = (left + right) >> 1 # the middle __UpperCAmelCase = find_max(snake_case_ , snake_case_ , snake_case_ ) # find max in range[left, mid] __UpperCAmelCase = find_max(snake_case_ , mid + 1 , snake_case_ ) # find max in range[mid + 1, right] return left_max if left_max >= right_max else right_max if __name__ == "__main__": import doctest doctest.testmod(verbose=True)
332
"""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 lowercase__ ( snake_case_ :Union[str, Any]=None ): if subparsers is not None: __UpperCAmelCase = subparsers.add_parser('''env''' ) else: __UpperCAmelCase = argparse.ArgumentParser('''Accelerate env command''' ) parser.add_argument( '''--config_file''' , default=snake_case_ , help='''The config file to use for the default values in the launching script.''' ) if subparsers is not None: parser.set_defaults(func=snake_case_ ) return parser def lowercase__ ( snake_case_ :List[Any] ): __UpperCAmelCase = torch.__version__ __UpperCAmelCase = torch.cuda.is_available() __UpperCAmelCase = is_xpu_available() __UpperCAmelCase = is_npu_available() __UpperCAmelCase = '''Not found''' # Get the default from the config file. if args.config_file is not None or os.path.isfile(snake_case_ ): __UpperCAmelCase = load_config_from_file(args.config_file ).to_dict() __UpperCAmelCase = { '''`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(snake_case_ ), '''PyTorch NPU available''': str(snake_case_ ), '''System RAM''': F'''{psutil.virtual_memory().total / 1_024 ** 3:.2f} GB''', } if pt_cuda_available: __UpperCAmelCase = 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 = ( '''\n'''.join([F'''\t- {prop}: {val}''' for prop, val in accelerate_config.items()] ) if isinstance(snake_case_ , snake_case_ ) else F'''\t{accelerate_config}''' ) print(snake_case_ ) __UpperCAmelCase = accelerate_config return info def lowercase__ ( ): __UpperCAmelCase = env_command_parser() __UpperCAmelCase = parser.parse_args() env_command(snake_case_ ) return 0 if __name__ == "__main__": raise SystemExit(main())
332
1
"""simple docstring""" import warnings from diffusers import StableDiffusionInpaintPipeline as StableDiffusionInpaintPipeline # noqa F401 warnings.warn( 'The `inpainting.py` script is outdated. Please use directly `from diffusers import' ' StableDiffusionInpaintPipeline` instead.' )
332
"""simple docstring""" import shutil import tempfile import unittest from transformers import SPIECE_UNDERLINE, BatchEncoding, MBartaaTokenizer, MBartaaTokenizerFast, is_torch_available from transformers.testing_utils import ( get_tests_dir, nested_simplify, require_sentencepiece, require_tokenizers, require_torch, slow, ) from ...test_tokenization_common import TokenizerTesterMixin _lowercase : Tuple = get_tests_dir('fixtures/test_sentencepiece.model') if is_torch_available(): from transformers.models.mbart.modeling_mbart import shift_tokens_right _lowercase : List[str] = 25_00_04 _lowercase : int = 25_00_20 @require_sentencepiece @require_tokenizers class _UpperCAmelCase ( _lowerCAmelCase , unittest.TestCase ): a__ : Union[str, Any] = MBartaaTokenizer a__ : List[str] = MBartaaTokenizerFast a__ : Any = True a__ : List[str] = True def a ( self : str ): super().setUp() # We have a SentencePiece fixture for testing __UpperCAmelCase = MBartaaTokenizer(_lowercase , src_lang='''en_XX''' , tgt_lang='''ro_RO''' , keep_accents=_lowercase ) tokenizer.save_pretrained(self.tmpdirname ) def a ( self : Dict ): __UpperCAmelCase = '''<s>''' __UpperCAmelCase = 0 self.assertEqual(self.get_tokenizer()._convert_token_to_id(_lowercase ) , _lowercase ) self.assertEqual(self.get_tokenizer()._convert_id_to_token(_lowercase ) , _lowercase ) def a ( self : Optional[Any] ): __UpperCAmelCase = list(self.get_tokenizer().get_vocab().keys() ) self.assertEqual(vocab_keys[0] , '''<s>''' ) self.assertEqual(vocab_keys[1] , '''<pad>''' ) self.assertEqual(vocab_keys[-1] , '''<mask>''' ) self.assertEqual(len(_lowercase ) , 10_54 ) def a ( self : Tuple ): self.assertEqual(self.get_tokenizer().vocab_size , 10_54 ) def a ( self : str ): __UpperCAmelCase = MBartaaTokenizer(_lowercase , src_lang='''en_XX''' , tgt_lang='''ro_RO''' , keep_accents=_lowercase ) __UpperCAmelCase = tokenizer.tokenize('''This is a test''' ) self.assertListEqual(_lowercase , ['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est'''] ) self.assertListEqual( tokenizer.convert_tokens_to_ids(_lowercase ) , [value + tokenizer.fairseq_offset for value in [2_85, 46, 10, 1_70, 3_82]] , ) __UpperCAmelCase = tokenizer.tokenize('''I was born in 92000, and this is falsé.''' ) self.assertListEqual( _lowercase , [SPIECE_UNDERLINE + '''I''', SPIECE_UNDERLINE + '''was''', SPIECE_UNDERLINE + '''b''', '''or''', '''n''', SPIECE_UNDERLINE + '''in''', SPIECE_UNDERLINE + '''''', '''9''', '''2''', '''0''', '''0''', '''0''', ''',''', SPIECE_UNDERLINE + '''and''', SPIECE_UNDERLINE + '''this''', SPIECE_UNDERLINE + '''is''', SPIECE_UNDERLINE + '''f''', '''al''', '''s''', '''é''', '''.'''] , ) __UpperCAmelCase = tokenizer.convert_tokens_to_ids(_lowercase ) self.assertListEqual( _lowercase , [ value + tokenizer.fairseq_offset for value in [8, 21, 84, 55, 24, 19, 7, 2, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 2, 4] ] , ) __UpperCAmelCase = tokenizer.convert_ids_to_tokens(_lowercase ) self.assertListEqual( _lowercase , [SPIECE_UNDERLINE + '''I''', SPIECE_UNDERLINE + '''was''', SPIECE_UNDERLINE + '''b''', '''or''', '''n''', SPIECE_UNDERLINE + '''in''', SPIECE_UNDERLINE + '''''', '''<unk>''', '''2''', '''0''', '''0''', '''0''', ''',''', SPIECE_UNDERLINE + '''and''', SPIECE_UNDERLINE + '''this''', SPIECE_UNDERLINE + '''is''', SPIECE_UNDERLINE + '''f''', '''al''', '''s''', '''<unk>''', '''.'''] , ) @slow def a ( self : str ): # fmt: off __UpperCAmelCase = {'''input_ids''': [[25_00_04, 1_10_62, 8_27_72, 7, 15, 8_27_72, 5_38, 5_15_29, 2_37, 1_71_98, 12_90, 2_06, 9, 21_51_75, 13_14, 1_36, 1_71_98, 12_90, 2_06, 9, 5_63_59, 42, 12_20_09, 9, 1_64_66, 16, 8_73_44, 45_37, 9, 47_17, 7_83_81, 6, 15_99_58, 7, 15, 2_44_80, 6_18, 4, 5_27, 2_26_93, 54_28, 4, 27_77, 2_44_80, 98_74, 4, 4_35_23, 5_94, 4, 8_03, 1_83_92, 3_31_89, 18, 4, 4_35_23, 2_44_47, 1_23_99, 1_00, 2_49_55, 8_36_58, 96_26, 14_40_57, 15, 8_39, 2_23_35, 16, 1_36, 2_49_55, 8_36_58, 8_34_79, 15, 3_91_02, 7_24, 16, 6_78, 6_45, 27_89, 13_28, 45_89, 42, 12_20_09, 11_57_74, 23, 8_05, 13_28, 4_68_76, 7, 1_36, 5_38_94, 19_40, 4_22_27, 4_11_59, 1_77_21, 8_23, 4_25, 4, 2_75_12, 9_87_22, 2_06, 1_36, 55_31, 49_70, 9_19, 1_73_36, 5, 2], [25_00_04, 2_00_80, 6_18, 83, 8_27_75, 47, 4_79, 9, 15_17, 73, 5_38_94, 3_33, 8_05_81, 11_01_17, 1_88_11, 52_56, 12_95, 51, 15_25_26, 2_97, 79_86, 3_90, 12_44_16, 5_38, 3_54_31, 2_14, 98, 1_50_44, 2_57_37, 1_36, 71_08, 4_37_01, 23, 7_56, 13_53_55, 7, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [25_00_04, 5_81, 6_37_73, 11_94_55, 6, 14_77_97, 8_82_03, 7, 6_45, 70, 21, 32_85, 1_02_69, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], '''attention_mask''': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]} # noqa: E501 # fmt: on self.tokenizer_integration_test_util( expected_encoding=_lowercase , model_name='''facebook/mbart-large-50''' , revision='''d3913889c59cd5c9e456b269c376325eabad57e2''' , ) def a ( self : 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 __UpperCAmelCase = (self.rust_tokenizer_class, '''hf-internal-testing/tiny-random-mbart50''', {}) for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})''' ): __UpperCAmelCase = self.rust_tokenizer_class.from_pretrained(_lowercase , **_lowercase ) __UpperCAmelCase = self.tokenizer_class.from_pretrained(_lowercase , **_lowercase ) __UpperCAmelCase = tempfile.mkdtemp() __UpperCAmelCase = tokenizer_r.save_pretrained(_lowercase ) __UpperCAmelCase = tokenizer_p.save_pretrained(_lowercase ) # Checks it save with the same files + the tokenizer.json file for the fast one self.assertTrue(any('''tokenizer.json''' in f for f in tokenizer_r_files ) ) __UpperCAmelCase = tuple(f for f in tokenizer_r_files if '''tokenizer.json''' not in f ) self.assertSequenceEqual(_lowercase , _lowercase ) # Checks everything loads correctly in the same way __UpperCAmelCase = tokenizer_r.from_pretrained(_lowercase ) __UpperCAmelCase = tokenizer_p.from_pretrained(_lowercase ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(_lowercase , _lowercase ) ) # self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key)) # self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id")) shutil.rmtree(_lowercase ) # Save tokenizer rust, legacy_format=True __UpperCAmelCase = tempfile.mkdtemp() __UpperCAmelCase = tokenizer_r.save_pretrained(_lowercase , legacy_format=_lowercase ) __UpperCAmelCase = tokenizer_p.save_pretrained(_lowercase ) # Checks it save with the same files self.assertSequenceEqual(_lowercase , _lowercase ) # Checks everything loads correctly in the same way __UpperCAmelCase = tokenizer_r.from_pretrained(_lowercase ) __UpperCAmelCase = tokenizer_p.from_pretrained(_lowercase ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(_lowercase , _lowercase ) ) shutil.rmtree(_lowercase ) # Save tokenizer rust, legacy_format=False __UpperCAmelCase = tempfile.mkdtemp() __UpperCAmelCase = tokenizer_r.save_pretrained(_lowercase , legacy_format=_lowercase ) __UpperCAmelCase = tokenizer_p.save_pretrained(_lowercase ) # Checks it saved the tokenizer.json file self.assertTrue(any('''tokenizer.json''' in f for f in tokenizer_r_files ) ) # Checks everything loads correctly in the same way __UpperCAmelCase = tokenizer_r.from_pretrained(_lowercase ) __UpperCAmelCase = tokenizer_p.from_pretrained(_lowercase ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(_lowercase , _lowercase ) ) shutil.rmtree(_lowercase ) @require_torch @require_sentencepiece @require_tokenizers class _UpperCAmelCase ( unittest.TestCase ): a__ : str = "facebook/mbart-large-50-one-to-many-mmt" a__ : Union[str, Any] = [ " UN Chief Says There Is No Military Solution in Syria", " Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.", ] a__ : Any = [ "Şeful ONU declară că nu există o soluţie militară în Siria", "Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei" " pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor" " face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.", ] a__ : Any = [EN_CODE, 8_274, 127_873, 25_916, 7, 8_622, 2_071, 438, 67_485, 53, 187_895, 23, 51_712, 2] @classmethod def a ( cls : Tuple ): __UpperCAmelCase = MBartaaTokenizer.from_pretrained( cls.checkpoint_name , src_lang='''en_XX''' , tgt_lang='''ro_RO''' ) __UpperCAmelCase = 1 return cls def a ( self : Union[str, Any] ): self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ar_AR'''] , 25_00_01 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''en_EN'''] , 25_00_04 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ro_RO'''] , 25_00_20 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''mr_IN'''] , 25_00_38 ) def a ( self : Union[str, Any] ): __UpperCAmelCase = self.tokenizer.batch_encode_plus(self.src_text ).input_ids[0] self.assertListEqual(self.expected_src_tokens , _lowercase ) def a ( self : Optional[Any] ): self.assertIn(_lowercase , self.tokenizer.all_special_ids ) __UpperCAmelCase = [RO_CODE, 8_84, 90_19, 96, 9, 9_16, 8_67_92, 36, 1_87_43, 1_55_96, 5, 2] __UpperCAmelCase = self.tokenizer.decode(_lowercase , skip_special_tokens=_lowercase ) __UpperCAmelCase = self.tokenizer.decode(generated_ids[1:] , skip_special_tokens=_lowercase ) self.assertEqual(_lowercase , _lowercase ) self.assertNotIn(self.tokenizer.eos_token , _lowercase ) def a ( self : Optional[Any] ): __UpperCAmelCase = ['''this is gunna be a long sentence ''' * 20] assert isinstance(src_text[0] , _lowercase ) __UpperCAmelCase = 10 __UpperCAmelCase = self.tokenizer(_lowercase , max_length=_lowercase , truncation=_lowercase ).input_ids[0] self.assertEqual(ids[0] , _lowercase ) self.assertEqual(ids[-1] , 2 ) self.assertEqual(len(_lowercase ) , _lowercase ) def a ( self : Optional[int] ): self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['''<mask>''', '''ar_AR'''] ) , [25_00_53, 25_00_01] ) def a ( self : Union[str, Any] ): __UpperCAmelCase = tempfile.mkdtemp() __UpperCAmelCase = self.tokenizer.fairseq_tokens_to_ids self.tokenizer.save_pretrained(_lowercase ) __UpperCAmelCase = MBartaaTokenizer.from_pretrained(_lowercase ) self.assertDictEqual(new_tok.fairseq_tokens_to_ids , _lowercase ) @require_torch def a ( self : Dict ): __UpperCAmelCase = self.tokenizer(self.src_text , text_target=self.tgt_text , padding=_lowercase , return_tensors='''pt''' ) __UpperCAmelCase = shift_tokens_right(batch['''labels'''] , self.tokenizer.pad_token_id ) # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4 assert batch.input_ids[1][0] == EN_CODE assert batch.input_ids[1][-1] == 2 assert batch.labels[1][0] == RO_CODE assert batch.labels[1][-1] == 2 assert batch.decoder_input_ids[1][:2].tolist() == [2, RO_CODE] @require_torch def a ( self : Union[str, Any] ): __UpperCAmelCase = self.tokenizer( self.src_text , text_target=self.tgt_text , padding=_lowercase , truncation=_lowercase , max_length=len(self.expected_src_tokens ) , return_tensors='''pt''' , ) __UpperCAmelCase = shift_tokens_right(batch['''labels'''] , self.tokenizer.pad_token_id ) self.assertIsInstance(_lowercase , _lowercase ) self.assertEqual((2, 14) , batch.input_ids.shape ) self.assertEqual((2, 14) , batch.attention_mask.shape ) __UpperCAmelCase = batch.input_ids.tolist()[0] self.assertListEqual(self.expected_src_tokens , _lowercase ) self.assertEqual(2 , batch.decoder_input_ids[0, 0] ) # decoder_start_token_id # Test that special tokens are reset self.assertEqual(self.tokenizer.prefix_tokens , [EN_CODE] ) self.assertEqual(self.tokenizer.suffix_tokens , [self.tokenizer.eos_token_id] ) def a ( self : Union[str, Any] ): __UpperCAmelCase = self.tokenizer(self.src_text , padding=_lowercase , truncation=_lowercase , max_length=3 , return_tensors='''pt''' ) __UpperCAmelCase = self.tokenizer( text_target=self.tgt_text , padding=_lowercase , truncation=_lowercase , max_length=10 , return_tensors='''pt''' ) __UpperCAmelCase = targets['''input_ids'''] __UpperCAmelCase = shift_tokens_right(_lowercase , self.tokenizer.pad_token_id ) self.assertEqual(batch.input_ids.shape[1] , 3 ) self.assertEqual(batch.decoder_input_ids.shape[1] , 10 ) @require_torch def a ( self : Dict ): __UpperCAmelCase = self.tokenizer._build_translation_inputs( '''A test''' , return_tensors='''pt''' , src_lang='''en_XX''' , tgt_lang='''ar_AR''' ) self.assertEqual( nested_simplify(_lowercase ) , { # en_XX, A, test, EOS '''input_ids''': [[25_00_04, 62, 30_34, 2]], '''attention_mask''': [[1, 1, 1, 1]], # ar_AR '''forced_bos_token_id''': 25_00_01, } , )
332
1
"""simple docstring""" import gc import random import unittest import numpy as np import torch from PIL import Image from diffusers import ( DDIMScheduler, KandinskyVaaControlnetImgaImgPipeline, KandinskyVaaPriorEmbaEmbPipeline, UNetaDConditionModel, VQModel, ) from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference enable_full_determinism() class _UpperCAmelCase ( _lowerCAmelCase , unittest.TestCase ): a__ : List[Any] = KandinskyVaaControlnetImgaImgPipeline a__ : int = ["image_embeds", "negative_image_embeds", "image", "hint"] a__ : List[str] = ["image_embeds", "negative_image_embeds", "image", "hint"] a__ : Union[str, Any] = [ "generator", "height", "width", "strength", "guidance_scale", "num_inference_steps", "return_dict", "guidance_scale", "num_images_per_prompt", "output_type", "return_dict", ] a__ : Optional[int] = False @property def a ( self : Dict ): return 32 @property def a ( self : str ): return 32 @property def a ( self : Union[str, Any] ): return self.time_input_dim @property def a ( self : Optional[Any] ): return self.time_input_dim * 4 @property def a ( self : List[Any] ): return 1_00 @property def a ( self : Optional[Any] ): torch.manual_seed(0 ) __UpperCAmelCase = { '''in_channels''': 8, # Out channels is double in channels because predicts mean and variance '''out_channels''': 8, '''addition_embed_type''': '''image_hint''', '''down_block_types''': ('''ResnetDownsampleBlock2D''', '''SimpleCrossAttnDownBlock2D'''), '''up_block_types''': ('''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D'''), '''mid_block_type''': '''UNetMidBlock2DSimpleCrossAttn''', '''block_out_channels''': (self.block_out_channels_a, self.block_out_channels_a * 2), '''layers_per_block''': 1, '''encoder_hid_dim''': self.text_embedder_hidden_size, '''encoder_hid_dim_type''': '''image_proj''', '''cross_attention_dim''': self.cross_attention_dim, '''attention_head_dim''': 4, '''resnet_time_scale_shift''': '''scale_shift''', '''class_embed_type''': None, } __UpperCAmelCase = UNetaDConditionModel(**_lowercase ) return model @property def a ( self : List[str] ): return { "block_out_channels": [32, 32, 64, 64], "down_block_types": [ "DownEncoderBlock2D", "DownEncoderBlock2D", "DownEncoderBlock2D", "AttnDownEncoderBlock2D", ], "in_channels": 3, "latent_channels": 4, "layers_per_block": 1, "norm_num_groups": 8, "norm_type": "spatial", "num_vq_embeddings": 12, "out_channels": 3, "up_block_types": ["AttnUpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"], "vq_embed_dim": 4, } @property def a ( self : int ): torch.manual_seed(0 ) __UpperCAmelCase = VQModel(**self.dummy_movq_kwargs ) return model def a ( self : List[Any] ): __UpperCAmelCase = self.dummy_unet __UpperCAmelCase = self.dummy_movq __UpperCAmelCase = { '''num_train_timesteps''': 10_00, '''beta_schedule''': '''linear''', '''beta_start''': 0.00_085, '''beta_end''': 0.012, '''clip_sample''': False, '''set_alpha_to_one''': False, '''steps_offset''': 0, '''prediction_type''': '''epsilon''', '''thresholding''': False, } __UpperCAmelCase = DDIMScheduler(**_lowercase ) __UpperCAmelCase = { '''unet''': unet, '''scheduler''': scheduler, '''movq''': movq, } return components def a ( self : Dict , _lowercase : Tuple , _lowercase : Any=0 ): __UpperCAmelCase = floats_tensor((1, self.text_embedder_hidden_size) , rng=random.Random(_lowercase ) ).to(_lowercase ) __UpperCAmelCase = floats_tensor((1, self.text_embedder_hidden_size) , rng=random.Random(seed + 1 ) ).to( _lowercase ) # create init_image __UpperCAmelCase = floats_tensor((1, 3, 64, 64) , rng=random.Random(_lowercase ) ).to(_lowercase ) __UpperCAmelCase = image.cpu().permute(0 , 2 , 3 , 1 )[0] __UpperCAmelCase = Image.fromarray(np.uinta(_lowercase ) ).convert('''RGB''' ).resize((2_56, 2_56) ) # create hint __UpperCAmelCase = floats_tensor((1, 3, 64, 64) , rng=random.Random(_lowercase ) ).to(_lowercase ) if str(_lowercase ).startswith('''mps''' ): __UpperCAmelCase = torch.manual_seed(_lowercase ) else: __UpperCAmelCase = torch.Generator(device=_lowercase ).manual_seed(_lowercase ) __UpperCAmelCase = { '''image''': init_image, '''image_embeds''': image_embeds, '''negative_image_embeds''': negative_image_embeds, '''hint''': hint, '''generator''': generator, '''height''': 64, '''width''': 64, '''num_inference_steps''': 10, '''guidance_scale''': 7.0, '''strength''': 0.2, '''output_type''': '''np''', } return inputs def a ( self : str ): __UpperCAmelCase = '''cpu''' __UpperCAmelCase = self.get_dummy_components() __UpperCAmelCase = self.pipeline_class(**_lowercase ) __UpperCAmelCase = pipe.to(_lowercase ) pipe.set_progress_bar_config(disable=_lowercase ) __UpperCAmelCase = pipe(**self.get_dummy_inputs(_lowercase ) ) __UpperCAmelCase = output.images __UpperCAmelCase = pipe( **self.get_dummy_inputs(_lowercase ) , return_dict=_lowercase , )[0] __UpperCAmelCase = image[0, -3:, -3:, -1] __UpperCAmelCase = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) __UpperCAmelCase = np.array( [0.54_985_034, 0.55_509_365, 0.52_561_504, 0.5_570_494, 0.5_593_818, 0.5_263_979, 0.50_285_643, 0.5_069_846, 0.51_196_736] ) assert ( np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2 ), F''' expected_slice {expected_slice}, but got {image_slice.flatten()}''' assert ( np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1E-2 ), F''' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}''' @slow @require_torch_gpu class _UpperCAmelCase ( unittest.TestCase ): def a ( self : Dict ): # clean up the VRAM after each test super().tearDown() gc.collect() torch.cuda.empty_cache() def a ( self : Tuple ): __UpperCAmelCase = load_numpy( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/kandinskyv22/kandinskyv22_controlnet_img2img_robotcat_fp16.npy''' ) __UpperCAmelCase = load_image( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/kandinsky/cat.png''' ) __UpperCAmelCase = init_image.resize((5_12, 5_12) ) __UpperCAmelCase = load_image( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/kandinskyv22/hint_image_cat.png''' ) __UpperCAmelCase = torch.from_numpy(np.array(_lowercase ) ).float() / 255.0 __UpperCAmelCase = hint.permute(2 , 0 , 1 ).unsqueeze(0 ) __UpperCAmelCase = '''A robot, 4k photo''' __UpperCAmelCase = KandinskyVaaPriorEmbaEmbPipeline.from_pretrained( '''kandinsky-community/kandinsky-2-2-prior''' , torch_dtype=torch.floataa ) pipe_prior.to(_lowercase ) __UpperCAmelCase = KandinskyVaaControlnetImgaImgPipeline.from_pretrained( '''kandinsky-community/kandinsky-2-2-controlnet-depth''' , torch_dtype=torch.floataa ) __UpperCAmelCase = pipeline.to(_lowercase ) pipeline.set_progress_bar_config(disable=_lowercase ) __UpperCAmelCase = torch.Generator(device='''cpu''' ).manual_seed(0 ) __UpperCAmelCase , __UpperCAmelCase = pipe_prior( _lowercase , image=_lowercase , strength=0.85 , generator=_lowercase , negative_prompt='''''' , ).to_tuple() __UpperCAmelCase = pipeline( image=_lowercase , image_embeds=_lowercase , negative_image_embeds=_lowercase , hint=_lowercase , generator=_lowercase , num_inference_steps=1_00 , height=5_12 , width=5_12 , strength=0.5 , output_type='''np''' , ) __UpperCAmelCase = output.images[0] assert image.shape == (5_12, 5_12, 3) assert_mean_pixel_difference(_lowercase , _lowercase )
332
"""simple docstring""" import unittest import torch from torch import nn from accelerate.test_utils import require_cuda from accelerate.utils.memory import find_executable_batch_size, release_memory def lowercase__ ( ): raise RuntimeError('''CUDA out of memory.''' ) class _UpperCAmelCase ( nn.Module ): def __init__( self : Optional[Any] ): super().__init__() __UpperCAmelCase = nn.Linear(3 , 4 ) __UpperCAmelCase = nn.BatchNormad(4 ) __UpperCAmelCase = nn.Linear(4 , 5 ) def a ( self : Optional[int] , _lowercase : Optional[Any] ): return self.lineara(self.batchnorm(self.lineara(_lowercase ) ) ) class _UpperCAmelCase ( unittest.TestCase ): def a ( self : List[str] ): __UpperCAmelCase = [] @find_executable_batch_size(starting_batch_size=1_28 ) def mock_training_loop_function(_lowercase : Optional[int] ): nonlocal batch_sizes batch_sizes.append(_lowercase ) if batch_size != 8: raise_fake_out_of_memory() mock_training_loop_function() self.assertListEqual(_lowercase , [1_28, 64, 32, 16, 8] ) def a ( self : Optional[int] ): __UpperCAmelCase = [] @find_executable_batch_size(starting_batch_size=1_28 ) def mock_training_loop_function(_lowercase : str , _lowercase : List[str] ): nonlocal batch_sizes batch_sizes.append(_lowercase ) if batch_size != 8: raise_fake_out_of_memory() return batch_size, arga __UpperCAmelCase , __UpperCAmelCase = mock_training_loop_function('''hello''' ) self.assertListEqual(_lowercase , [1_28, 64, 32, 16, 8] ) self.assertListEqual([bs, arga] , [8, '''hello'''] ) def a ( self : Tuple ): @find_executable_batch_size(starting_batch_size=0 ) def mock_training_loop_function(_lowercase : Optional[int] ): pass with self.assertRaises(_lowercase ) as cm: mock_training_loop_function() self.assertIn('''No executable batch size found, reached zero.''' , cm.exception.args[0] ) def a ( self : List[Any] ): @find_executable_batch_size(starting_batch_size=16 ) def mock_training_loop_function(_lowercase : List[Any] ): if batch_size > 0: raise_fake_out_of_memory() pass with self.assertRaises(_lowercase ) as cm: mock_training_loop_function() self.assertIn('''No executable batch size found, reached zero.''' , cm.exception.args[0] ) def a ( self : Union[str, Any] ): @find_executable_batch_size(starting_batch_size=1_28 ) def mock_training_loop_function(_lowercase : Optional[Any] , _lowercase : List[str] , _lowercase : str ): if batch_size != 8: raise raise_fake_out_of_memory() with self.assertRaises(_lowercase ) as cm: mock_training_loop_function(1_28 , '''hello''' , '''world''' ) self.assertIn('''Batch size was passed into `f`''' , cm.exception.args[0] ) self.assertIn('''`f(arg1=\'hello\', arg2=\'world\')''' , cm.exception.args[0] ) def a ( self : Dict ): @find_executable_batch_size(starting_batch_size=16 ) def mock_training_loop_function(_lowercase : int ): raise ValueError('''Oops, we had an error!''' ) with self.assertRaises(_lowercase ) as cm: mock_training_loop_function() self.assertIn('''Oops, we had an error!''' , cm.exception.args[0] ) @require_cuda def a ( self : str ): __UpperCAmelCase = torch.cuda.memory_allocated() __UpperCAmelCase = ModelForTest() model.cuda() self.assertGreater(torch.cuda.memory_allocated() , _lowercase ) __UpperCAmelCase = release_memory(_lowercase ) self.assertEqual(torch.cuda.memory_allocated() , _lowercase )
332
1
"""simple docstring""" from ..utils import DummyObject, requires_backends class _UpperCAmelCase ( metaclass=_lowerCAmelCase ): a__ : List[str] = ["note_seq"] def __init__( self : Tuple , *_lowercase : Optional[int] , **_lowercase : List[str] ): requires_backends(self , ['''note_seq'''] ) @classmethod def a ( cls : List[Any] , *_lowercase : Any , **_lowercase : Tuple ): requires_backends(cls , ['''note_seq'''] ) @classmethod def a ( cls : Any , *_lowercase : Dict , **_lowercase : Tuple ): requires_backends(cls , ['''note_seq'''] )
332
"""simple docstring""" import argparse import copy def lowercase__ ( snake_case_ :Tuple ): __UpperCAmelCase = {} with open(snake_case_ ) as f: for line in f: if line.split()[0] not in dict_of_neighbours: __UpperCAmelCase = [] _list.append([line.split()[1], line.split()[2]] ) __UpperCAmelCase = _list else: dict_of_neighbours[line.split()[0]].append( [line.split()[1], line.split()[2]] ) if line.split()[1] not in dict_of_neighbours: __UpperCAmelCase = [] _list.append([line.split()[0], line.split()[2]] ) __UpperCAmelCase = _list else: dict_of_neighbours[line.split()[1]].append( [line.split()[0], line.split()[2]] ) return dict_of_neighbours def lowercase__ ( snake_case_ :Dict , snake_case_ :Optional[Any] ): with open(snake_case_ ) as f: __UpperCAmelCase = f.read(1 ) __UpperCAmelCase = start_node __UpperCAmelCase = [] __UpperCAmelCase = start_node __UpperCAmelCase = 0 while visiting not in first_solution: __UpperCAmelCase = 10_000 for k in dict_of_neighbours[visiting]: if int(k[1] ) < int(snake_case_ ) and k[0] not in first_solution: __UpperCAmelCase = k[1] __UpperCAmelCase = k[0] first_solution.append(snake_case_ ) __UpperCAmelCase = distance_of_first_solution + int(snake_case_ ) __UpperCAmelCase = best_node first_solution.append(snake_case_ ) __UpperCAmelCase = 0 for k in dict_of_neighbours[first_solution[-2]]: if k[0] == start_node: break position += 1 __UpperCAmelCase = ( distance_of_first_solution + int(dict_of_neighbours[first_solution[-2]][position][1] ) - 10_000 ) return first_solution, distance_of_first_solution def lowercase__ ( snake_case_ :int , snake_case_ :Tuple ): __UpperCAmelCase = [] for n in solution[1:-1]: __UpperCAmelCase = solution.index(snake_case_ ) for kn in solution[1:-1]: __UpperCAmelCase = solution.index(snake_case_ ) if n == kn: continue __UpperCAmelCase = copy.deepcopy(snake_case_ ) __UpperCAmelCase = kn __UpperCAmelCase = n __UpperCAmelCase = 0 for k in _tmp[:-1]: __UpperCAmelCase = _tmp[_tmp.index(snake_case_ ) + 1] for i in dict_of_neighbours[k]: if i[0] == next_node: __UpperCAmelCase = distance + int(i[1] ) _tmp.append(snake_case_ ) if _tmp not in neighborhood_of_solution: neighborhood_of_solution.append(_tmp ) __UpperCAmelCase = len(neighborhood_of_solution[0] ) - 1 neighborhood_of_solution.sort(key=lambda snake_case_ : x[index_of_last_item_in_the_list] ) return neighborhood_of_solution def lowercase__ ( snake_case_ :str , snake_case_ :Union[str, Any] , snake_case_ :Optional[int] , snake_case_ :Dict , snake_case_ :int ): __UpperCAmelCase = 1 __UpperCAmelCase = first_solution __UpperCAmelCase = [] __UpperCAmelCase = distance_of_first_solution __UpperCAmelCase = solution while count <= iters: __UpperCAmelCase = find_neighborhood(snake_case_ , snake_case_ ) __UpperCAmelCase = 0 __UpperCAmelCase = neighborhood[index_of_best_solution] __UpperCAmelCase = len(snake_case_ ) - 1 __UpperCAmelCase = False while not found: __UpperCAmelCase = 0 while i < len(snake_case_ ): if best_solution[i] != solution[i]: __UpperCAmelCase = best_solution[i] __UpperCAmelCase = solution[i] break __UpperCAmelCase = i + 1 if [first_exchange_node, second_exchange_node] not in tabu_list and [ second_exchange_node, first_exchange_node, ] not in tabu_list: tabu_list.append([first_exchange_node, second_exchange_node] ) __UpperCAmelCase = True __UpperCAmelCase = best_solution[:-1] __UpperCAmelCase = neighborhood[index_of_best_solution][best_cost_index] if cost < best_cost: __UpperCAmelCase = cost __UpperCAmelCase = solution else: __UpperCAmelCase = index_of_best_solution + 1 __UpperCAmelCase = neighborhood[index_of_best_solution] if len(snake_case_ ) >= size: tabu_list.pop(0 ) __UpperCAmelCase = count + 1 return best_solution_ever, best_cost def lowercase__ ( snake_case_ :str=None ): __UpperCAmelCase = generate_neighbours(args.File ) __UpperCAmelCase , __UpperCAmelCase = generate_first_solution( args.File , snake_case_ ) __UpperCAmelCase , __UpperCAmelCase = tabu_search( snake_case_ , snake_case_ , snake_case_ , args.Iterations , args.Size , ) print(F'''Best solution: {best_sol}, with total distance: {best_cost}.''' ) if __name__ == "__main__": _lowercase : List[str] = argparse.ArgumentParser(description='Tabu Search') parser.add_argument( '-f', '--File', type=str, help='Path to the file containing the data', required=True, ) parser.add_argument( '-i', '--Iterations', type=int, help='How many iterations the algorithm should perform', required=True, ) parser.add_argument( '-s', '--Size', type=int, help='Size of the tabu list', required=True ) # Pass the arguments to main method main(parser.parse_args())
332
1
"""simple docstring""" def lowercase__ ( ): __UpperCAmelCase = [] __UpperCAmelCase = 1 while len(snake_case_ ) < 1E6: constant.append(str(snake_case_ ) ) i += 1 __UpperCAmelCase = ''''''.join(snake_case_ ) return ( int(constant[0] ) * int(constant[9] ) * int(constant[99] ) * int(constant[999] ) * int(constant[9_999] ) * int(constant[99_999] ) * int(constant[999_999] ) ) if __name__ == "__main__": print(solution())
332
"""simple docstring""" import numpy as np from numpy import ndarray from scipy.optimize import Bounds, LinearConstraint, minimize def lowercase__ ( snake_case_ :ndarray ): return np.dot(snake_case_ , snake_case_ ) class _UpperCAmelCase : def __init__( self : Union[str, Any] , *, _lowercase : float = np.inf , _lowercase : str = "linear" , _lowercase : float = 0.0 , ): __UpperCAmelCase = regularization __UpperCAmelCase = gamma if kernel == "linear": __UpperCAmelCase = self.__linear elif kernel == "rbf": if self.gamma == 0: raise ValueError('''rbf kernel requires gamma''' ) if not isinstance(self.gamma , (float, int) ): raise ValueError('''gamma must be float or int''' ) if not self.gamma > 0: raise ValueError('''gamma must be > 0''' ) __UpperCAmelCase = self.__rbf # in the future, there could be a default value like in sklearn # sklear: def_gamma = 1/(n_features * X.var()) (wiki) # previously it was 1/(n_features) else: __UpperCAmelCase = F'''Unknown kernel: {kernel}''' raise ValueError(_lowercase ) def a ( self : Dict , _lowercase : ndarray , _lowercase : ndarray ): return np.dot(_lowercase , _lowercase ) def a ( self : Any , _lowercase : ndarray , _lowercase : ndarray ): return np.exp(-(self.gamma * norm_squared(vectora - vectora )) ) def a ( self : Union[str, Any] , _lowercase : list[ndarray] , _lowercase : ndarray ): __UpperCAmelCase = observations __UpperCAmelCase = classes # using Wolfe's Dual to calculate w. # Primal problem: minimize 1/2*norm_squared(w) # constraint: yn(w . xn + b) >= 1 # # With l a vector # Dual problem: maximize sum_n(ln) - # 1/2 * sum_n(sum_m(ln*lm*yn*ym*xn . xm)) # constraint: self.C >= ln >= 0 # and sum_n(ln*yn) = 0 # Then we get w using w = sum_n(ln*yn*xn) # At the end we can get b ~= mean(yn - w . xn) # # Since we use kernels, we only need l_star to calculate b # and to classify observations ((__UpperCAmelCase) , ) = np.shape(_lowercase ) def to_minimize(_lowercase : ndarray ) -> float: __UpperCAmelCase = 0 ((__UpperCAmelCase) , ) = np.shape(_lowercase ) for i in range(_lowercase ): for j in range(_lowercase ): s += ( candidate[i] * candidate[j] * classes[i] * classes[j] * self.kernel(observations[i] , observations[j] ) ) return 1 / 2 * s - sum(_lowercase ) __UpperCAmelCase = LinearConstraint(_lowercase , 0 , 0 ) __UpperCAmelCase = Bounds(0 , self.regularization ) __UpperCAmelCase = minimize( _lowercase , np.ones(_lowercase ) , bounds=_lowercase , constraints=[ly_contraint] ).x __UpperCAmelCase = l_star # calculating mean offset of separation plane to points __UpperCAmelCase = 0 for i in range(_lowercase ): for j in range(_lowercase ): s += classes[i] - classes[i] * self.optimum[i] * self.kernel( observations[i] , observations[j] ) __UpperCAmelCase = s / n def a ( self : List[Any] , _lowercase : ndarray ): __UpperCAmelCase = sum( self.optimum[n] * self.classes[n] * self.kernel(self.observations[n] , _lowercase ) for n in range(len(self.classes ) ) ) return 1 if s + self.offset >= 0 else -1 if __name__ == "__main__": import doctest doctest.testmod()
332
1
"""simple docstring""" from collections.abc import Callable def lowercase__ ( snake_case_ :Callable[[float], float] , snake_case_ :float , snake_case_ :float ): __UpperCAmelCase = a __UpperCAmelCase = b if function(snake_case_ ) == 0: # one of the a or b is a root for the function return a elif function(snake_case_ ) == 0: return b elif ( function(snake_case_ ) * function(snake_case_ ) > 0 ): # if none of these are root and they are both positive or negative, # then this algorithm can't find the root raise ValueError('''could not find root in given interval.''' ) else: __UpperCAmelCase = start + (end - start) / 2.0 while abs(start - mid ) > 10**-7: # until precisely equals to 10^-7 if function(snake_case_ ) == 0: return mid elif function(snake_case_ ) * function(snake_case_ ) < 0: __UpperCAmelCase = mid else: __UpperCAmelCase = mid __UpperCAmelCase = start + (end - start) / 2.0 return mid def lowercase__ ( snake_case_ :float ): return x**3 - 2 * x - 5 if __name__ == "__main__": print(bisection(f, 1, 10_00)) import doctest doctest.testmod()
332
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import _LazyModule _lowercase : int = {'processing_wav2vec2_with_lm': ['Wav2Vec2ProcessorWithLM']} if TYPE_CHECKING: from .processing_wavaveca_with_lm import WavaVecaProcessorWithLM else: import sys _lowercase : Union[str, Any] = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
332
1
"""simple docstring""" import logging import os from dataclasses import dataclass, field from typing import Dict, Optional import numpy as np from utils_multiple_choice import MultipleChoiceDataset, Split, processors import transformers from transformers import ( AutoConfig, AutoModelForMultipleChoice, AutoTokenizer, DataCollatorWithPadding, EvalPrediction, HfArgumentParser, Trainer, TrainingArguments, set_seed, ) from transformers.trainer_utils import is_main_process _lowercase : int = logging.getLogger(__name__) def lowercase__ ( snake_case_ :int , snake_case_ :Optional[int] ): return (preds == labels).mean() @dataclass class _UpperCAmelCase : a__ : str = field( metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"} ) a__ : Optional[str] = field( default=_lowerCAmelCase , metadata={"help": "Pretrained config name or path if not the same as model_name"} ) a__ : Optional[str] = field( default=_lowerCAmelCase , metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"} ) a__ : Optional[str] = field( default=_lowerCAmelCase , metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"} , ) @dataclass class _UpperCAmelCase : a__ : str = field(metadata={"help": "The name of the task to train on: " + ", ".join(processors.keys() )} ) a__ : str = field(metadata={"help": "Should contain the data files for the 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__ : bool = field( default=_lowerCAmelCase , metadata={"help": "Overwrite the cached training and evaluation sets"} ) def lowercase__ ( ): # See all possible arguments in src/transformers/training_args.py # or by passing the --help flag to this script. # We now keep distinct sets of args, for a cleaner separation of concerns. __UpperCAmelCase = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments) ) __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase = parser.parse_args_into_dataclasses() if ( os.path.exists(training_args.output_dir ) and os.listdir(training_args.output_dir ) and training_args.do_train and not training_args.overwrite_output_dir ): raise ValueError( F'''Output directory ({training_args.output_dir}) already exists and is not empty. Use''' ''' --overwrite_output_dir to overcome.''' ) # Setup logging logging.basicConfig( format='''%(asctime)s - %(levelname)s - %(name)s - %(message)s''' , datefmt='''%m/%d/%Y %H:%M:%S''' , level=logging.INFO if training_args.local_rank in [-1, 0] else logging.WARN , ) logger.warning( '''Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s''' , training_args.local_rank , training_args.device , training_args.n_gpu , bool(training_args.local_rank != -1 ) , training_args.fpaa , ) # Set the verbosity to info of the Transformers logger (on main process only): if is_main_process(training_args.local_rank ): transformers.utils.logging.set_verbosity_info() transformers.utils.logging.enable_default_handler() transformers.utils.logging.enable_explicit_format() logger.info('''Training/evaluation parameters %s''' , snake_case_ ) # Set seed set_seed(training_args.seed ) try: __UpperCAmelCase = processors[data_args.task_name]() __UpperCAmelCase = processor.get_labels() __UpperCAmelCase = len(snake_case_ ) except KeyError: raise ValueError('''Task not found: %s''' % (data_args.task_name) ) # Load pretrained model and tokenizer # # Distributed training: # The .from_pretrained methods guarantee that only one local process can concurrently # download model & vocab. __UpperCAmelCase = AutoConfig.from_pretrained( model_args.config_name if model_args.config_name else model_args.model_name_or_path , num_labels=snake_case_ , finetuning_task=data_args.task_name , cache_dir=model_args.cache_dir , ) __UpperCAmelCase = 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 , ) __UpperCAmelCase = AutoModelForMultipleChoice.from_pretrained( model_args.model_name_or_path , from_tf=bool('''.ckpt''' in model_args.model_name_or_path ) , config=snake_case_ , cache_dir=model_args.cache_dir , ) # Get datasets __UpperCAmelCase = ( MultipleChoiceDataset( data_dir=data_args.data_dir , tokenizer=snake_case_ , task=data_args.task_name , max_seq_length=data_args.max_seq_length , overwrite_cache=data_args.overwrite_cache , mode=Split.train , ) if training_args.do_train else None ) __UpperCAmelCase = ( MultipleChoiceDataset( data_dir=data_args.data_dir , tokenizer=snake_case_ , task=data_args.task_name , max_seq_length=data_args.max_seq_length , overwrite_cache=data_args.overwrite_cache , mode=Split.dev , ) if training_args.do_eval else None ) def compute_metrics(snake_case_ :EvalPrediction ) -> Dict: __UpperCAmelCase = np.argmax(p.predictions , axis=1 ) return {"acc": simple_accuracy(snake_case_ , p.label_ids )} # Data collator __UpperCAmelCase = DataCollatorWithPadding(snake_case_ , pad_to_multiple_of=8 ) if training_args.fpaa else None # Initialize our Trainer __UpperCAmelCase = Trainer( model=snake_case_ , args=snake_case_ , train_dataset=snake_case_ , eval_dataset=snake_case_ , compute_metrics=snake_case_ , data_collator=snake_case_ , ) # Training if training_args.do_train: trainer.train( model_path=model_args.model_name_or_path if os.path.isdir(model_args.model_name_or_path ) else None ) trainer.save_model() # For convenience, we also re-save the tokenizer to the same directory, # so that you can share your model easily on huggingface.co/models =) if trainer.is_world_master(): tokenizer.save_pretrained(training_args.output_dir ) # Evaluation __UpperCAmelCase = {} if training_args.do_eval: logger.info('''*** Evaluate ***''' ) __UpperCAmelCase = trainer.evaluate() __UpperCAmelCase = os.path.join(training_args.output_dir , '''eval_results.txt''' ) if trainer.is_world_master(): with open(snake_case_ , '''w''' ) as writer: logger.info('''***** Eval results *****''' ) for key, value in result.items(): logger.info(''' %s = %s''' , snake_case_ , snake_case_ ) writer.write('''%s = %s\n''' % (key, value) ) results.update(snake_case_ ) return results def lowercase__ ( snake_case_ :Optional[int] ): # For xla_spawn (TPUs) main() if __name__ == "__main__": main()
332
"""simple docstring""" from __future__ import annotations class _UpperCAmelCase : def __init__( self : Tuple , _lowercase : str , _lowercase : str ): __UpperCAmelCase , __UpperCAmelCase = text, pattern __UpperCAmelCase , __UpperCAmelCase = len(_lowercase ), len(_lowercase ) def a ( self : Optional[int] , _lowercase : str ): for i in range(self.patLen - 1 , -1 , -1 ): if char == self.pattern[i]: return i return -1 def a ( self : int , _lowercase : int ): for i in range(self.patLen - 1 , -1 , -1 ): if self.pattern[i] != self.text[current_pos + i]: return current_pos + i return -1 def a ( self : Optional[Any] ): # searches pattern in text and returns index positions __UpperCAmelCase = [] for i in range(self.textLen - self.patLen + 1 ): __UpperCAmelCase = self.mismatch_in_text(_lowercase ) if mismatch_index == -1: positions.append(_lowercase ) else: __UpperCAmelCase = self.match_in_pattern(self.text[mismatch_index] ) __UpperCAmelCase = ( mismatch_index - match_index ) # shifting index lgtm [py/multiple-definition] return positions _lowercase : str = 'ABAABA' _lowercase : Tuple = 'AB' _lowercase : Dict = BoyerMooreSearch(text, pattern) _lowercase : Any = bms.bad_character_heuristic() if len(positions) == 0: print('No match found') else: print('Pattern found in following positions: ') print(positions)
332
1
"""simple docstring""" from typing import Optional, Union import torch from torch import nn from ...configuration_utils import ConfigMixin, register_to_config from ...models.modeling_utils import ModelMixin class _UpperCAmelCase ( _lowerCAmelCase , _lowerCAmelCase ): @register_to_config def __init__( self : Tuple , _lowercase : int = 7_68 , ): super().__init__() __UpperCAmelCase = nn.Parameter(torch.zeros(1 , _lowercase ) ) __UpperCAmelCase = nn.Parameter(torch.ones(1 , _lowercase ) ) def a ( self : Any , _lowercase : Optional[Union[str, torch.device]] = None , _lowercase : Optional[torch.dtype] = None , ): __UpperCAmelCase = nn.Parameter(self.mean.to(_lowercase ).to(_lowercase ) ) __UpperCAmelCase = nn.Parameter(self.std.to(_lowercase ).to(_lowercase ) ) return self def a ( self : Optional[int] , _lowercase : List[Any] ): __UpperCAmelCase = (embeds - self.mean) * 1.0 / self.std return embeds def a ( self : List[str] , _lowercase : Optional[int] ): __UpperCAmelCase = (embeds * self.std) + self.mean return embeds
332
"""simple docstring""" from __future__ import annotations from collections import deque from collections.abc import Sequence from dataclasses import dataclass from typing import Any @dataclass class _UpperCAmelCase : a__ : int a__ : Node | None = None a__ : Node | None = None def lowercase__ ( ): __UpperCAmelCase = Node(1 ) __UpperCAmelCase = Node(2 ) __UpperCAmelCase = Node(3 ) __UpperCAmelCase = Node(4 ) __UpperCAmelCase = Node(5 ) return tree def lowercase__ ( snake_case_ :Node | None ): return [root.data, *preorder(root.left ), *preorder(root.right )] if root else [] def lowercase__ ( snake_case_ :Node | None ): return postorder(root.left ) + postorder(root.right ) + [root.data] if root else [] def lowercase__ ( snake_case_ :Node | None ): return [*inorder(root.left ), root.data, *inorder(root.right )] if root else [] def lowercase__ ( snake_case_ :Node | None ): return (max(height(root.left ) , height(root.right ) ) + 1) if root else 0 def lowercase__ ( snake_case_ :Node | None ): __UpperCAmelCase = [] if root is None: return output __UpperCAmelCase = deque([root] ) while process_queue: __UpperCAmelCase = process_queue.popleft() output.append(node.data ) if node.left: process_queue.append(node.left ) if node.right: process_queue.append(node.right ) return output def lowercase__ ( snake_case_ :Node | None , snake_case_ :int ): __UpperCAmelCase = [] def populate_output(snake_case_ :Node | None , snake_case_ :int ) -> None: if not root: return if level == 1: output.append(root.data ) elif level > 1: populate_output(root.left , level - 1 ) populate_output(root.right , level - 1 ) populate_output(snake_case_ , snake_case_ ) return output def lowercase__ ( snake_case_ :Node | None , snake_case_ :int ): __UpperCAmelCase = [] def populate_output(snake_case_ :Node | None , snake_case_ :int ) -> None: if root is None: return if level == 1: output.append(root.data ) elif level > 1: populate_output(root.right , level - 1 ) populate_output(root.left , level - 1 ) populate_output(snake_case_ , snake_case_ ) return output def lowercase__ ( snake_case_ :Node | None ): if root is None: return [] __UpperCAmelCase = [] __UpperCAmelCase = 0 __UpperCAmelCase = height(snake_case_ ) for h in range(1 , height_tree + 1 ): if not flag: output.append(get_nodes_from_left_to_right(snake_case_ , snake_case_ ) ) __UpperCAmelCase = 1 else: output.append(get_nodes_from_right_to_left(snake_case_ , snake_case_ ) ) __UpperCAmelCase = 0 return output def lowercase__ ( ): # Main function for testing. __UpperCAmelCase = make_tree() print(F'''In-order Traversal: {inorder(snake_case_ )}''' ) print(F'''Pre-order Traversal: {preorder(snake_case_ )}''' ) print(F'''Post-order Traversal: {postorder(snake_case_ )}''' , '''\n''' ) print(F'''Height of Tree: {height(snake_case_ )}''' , '''\n''' ) print('''Complete Level Order Traversal: ''' ) print(level_order(snake_case_ ) , '''\n''' ) print('''Level-wise order Traversal: ''' ) for level in range(1 , height(snake_case_ ) + 1 ): print(F'''Level {level}:''' , get_nodes_from_left_to_right(snake_case_ , level=snake_case_ ) ) print('''\nZigZag order Traversal: ''' ) print(zigzag(snake_case_ ) ) if __name__ == "__main__": import doctest doctest.testmod() main()
332
1
"""simple docstring""" import argparse import gc import json import os import shutil import warnings import torch from transformers import LlamaConfig, LlamaForCausalLM, LlamaTokenizer try: from transformers import LlamaTokenizerFast except ImportError as e: warnings.warn(e) warnings.warn( 'The converted tokenizer will be the `slow` tokenizer. To use the fast, update your `tokenizers` library and re-run the tokenizer conversion' ) _lowercase : Optional[int] = None _lowercase : Optional[Any] = { '7B': 1_10_08, '13B': 1_38_24, '30B': 1_79_20, '65B': 2_20_16, '70B': 2_86_72, } _lowercase : Tuple = { '7B': 1, '7Bf': 1, '13B': 2, '13Bf': 2, '30B': 4, '65B': 8, '70B': 8, '70Bf': 8, } def lowercase__ ( snake_case_ :Tuple , snake_case_ :Union[str, Any]=1 , snake_case_ :str=256 ): return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3 ) ) + multiple_of - 1) // multiple_of) def lowercase__ ( snake_case_ :Tuple ): with open(snake_case_ , '''r''' ) as f: return json.load(snake_case_ ) def lowercase__ ( snake_case_ :List[str] , snake_case_ :str ): with open(snake_case_ , '''w''' ) as f: json.dump(snake_case_ , snake_case_ ) def lowercase__ ( snake_case_ :Any , snake_case_ :Optional[Any] , snake_case_ :Tuple , snake_case_ :Optional[int]=True ): os.makedirs(snake_case_ , exist_ok=snake_case_ ) __UpperCAmelCase = os.path.join(snake_case_ , '''tmp''' ) os.makedirs(snake_case_ , exist_ok=snake_case_ ) __UpperCAmelCase = read_json(os.path.join(snake_case_ , '''params.json''' ) ) __UpperCAmelCase = NUM_SHARDS[model_size] __UpperCAmelCase = params['''n_layers'''] __UpperCAmelCase = params['''n_heads'''] __UpperCAmelCase = n_heads // num_shards __UpperCAmelCase = params['''dim'''] __UpperCAmelCase = dim // n_heads __UpperCAmelCase = 10000.0 __UpperCAmelCase = 1.0 / (base ** (torch.arange(0 , snake_case_ , 2 ).float() / dims_per_head)) if "n_kv_heads" in params: __UpperCAmelCase = params['''n_kv_heads'''] # for GQA / MQA __UpperCAmelCase = n_heads_per_shard // num_key_value_heads __UpperCAmelCase = dim // num_key_value_heads else: # compatibility with other checkpoints __UpperCAmelCase = n_heads __UpperCAmelCase = n_heads_per_shard __UpperCAmelCase = dim # permute for sliced rotary def permute(snake_case_ :int , snake_case_ :List[str]=n_heads , snake_case_ :List[Any]=dim , snake_case_ :Dict=dim ): return w.view(snake_case_ , dima // n_heads // 2 , 2 , snake_case_ ).transpose(1 , 2 ).reshape(snake_case_ , snake_case_ ) print(F'''Fetching all parameters from the checkpoint at {input_base_path}.''' ) # Load weights if model_size == "7B": # Not sharded # (The sharded implementation would also work, but this is simpler.) __UpperCAmelCase = torch.load(os.path.join(snake_case_ , '''consolidated.00.pth''' ) , map_location='''cpu''' ) else: # Sharded __UpperCAmelCase = [ torch.load(os.path.join(snake_case_ , F'''consolidated.{i:02d}.pth''' ) , map_location='''cpu''' ) for i in range(snake_case_ ) ] __UpperCAmelCase = 0 __UpperCAmelCase = {'''weight_map''': {}} for layer_i in range(snake_case_ ): __UpperCAmelCase = F'''pytorch_model-{layer_i + 1}-of-{n_layers + 1}.bin''' if model_size == "7B": # Unsharded __UpperCAmelCase = { F'''model.layers.{layer_i}.self_attn.q_proj.weight''': permute( loaded[F'''layers.{layer_i}.attention.wq.weight'''] ), F'''model.layers.{layer_i}.self_attn.k_proj.weight''': permute( loaded[F'''layers.{layer_i}.attention.wk.weight'''] ), F'''model.layers.{layer_i}.self_attn.v_proj.weight''': loaded[F'''layers.{layer_i}.attention.wv.weight'''], F'''model.layers.{layer_i}.self_attn.o_proj.weight''': loaded[F'''layers.{layer_i}.attention.wo.weight'''], F'''model.layers.{layer_i}.mlp.gate_proj.weight''': loaded[F'''layers.{layer_i}.feed_forward.w1.weight'''], F'''model.layers.{layer_i}.mlp.down_proj.weight''': loaded[F'''layers.{layer_i}.feed_forward.w2.weight'''], F'''model.layers.{layer_i}.mlp.up_proj.weight''': loaded[F'''layers.{layer_i}.feed_forward.w3.weight'''], F'''model.layers.{layer_i}.input_layernorm.weight''': loaded[F'''layers.{layer_i}.attention_norm.weight'''], F'''model.layers.{layer_i}.post_attention_layernorm.weight''': loaded[F'''layers.{layer_i}.ffn_norm.weight'''], } else: # Sharded # Note that attention.w{q,k,v,o}, feed_fordward.w[1,2,3], attention_norm.weight and ffn_norm.weight share # the same storage object, saving attention_norm and ffn_norm will save other weights too, which is # redundant as other weights will be stitched from multiple shards. To avoid that, they are cloned. __UpperCAmelCase = { F'''model.layers.{layer_i}.input_layernorm.weight''': loaded[0][ F'''layers.{layer_i}.attention_norm.weight''' ].clone(), F'''model.layers.{layer_i}.post_attention_layernorm.weight''': loaded[0][ F'''layers.{layer_i}.ffn_norm.weight''' ].clone(), } __UpperCAmelCase = permute( torch.cat( [ loaded[i][F'''layers.{layer_i}.attention.wq.weight'''].view(snake_case_ , snake_case_ , snake_case_ ) for i in range(snake_case_ ) ] , dim=0 , ).reshape(snake_case_ , snake_case_ ) ) __UpperCAmelCase = permute( torch.cat( [ loaded[i][F'''layers.{layer_i}.attention.wk.weight'''].view( snake_case_ , snake_case_ , snake_case_ ) for i in range(snake_case_ ) ] , dim=0 , ).reshape(snake_case_ , snake_case_ ) , snake_case_ , snake_case_ , snake_case_ , ) __UpperCAmelCase = torch.cat( [ loaded[i][F'''layers.{layer_i}.attention.wv.weight'''].view( snake_case_ , snake_case_ , snake_case_ ) for i in range(snake_case_ ) ] , dim=0 , ).reshape(snake_case_ , snake_case_ ) __UpperCAmelCase = torch.cat( [loaded[i][F'''layers.{layer_i}.attention.wo.weight'''] for i in range(snake_case_ )] , dim=1 ) __UpperCAmelCase = torch.cat( [loaded[i][F'''layers.{layer_i}.feed_forward.w1.weight'''] for i in range(snake_case_ )] , dim=0 ) __UpperCAmelCase = torch.cat( [loaded[i][F'''layers.{layer_i}.feed_forward.w2.weight'''] for i in range(snake_case_ )] , dim=1 ) __UpperCAmelCase = torch.cat( [loaded[i][F'''layers.{layer_i}.feed_forward.w3.weight'''] for i in range(snake_case_ )] , dim=0 ) __UpperCAmelCase = inv_freq for k, v in state_dict.items(): __UpperCAmelCase = filename param_count += v.numel() torch.save(snake_case_ , os.path.join(snake_case_ , snake_case_ ) ) __UpperCAmelCase = F'''pytorch_model-{n_layers + 1}-of-{n_layers + 1}.bin''' if model_size == "7B": # Unsharded __UpperCAmelCase = { '''model.embed_tokens.weight''': loaded['''tok_embeddings.weight'''], '''model.norm.weight''': loaded['''norm.weight'''], '''lm_head.weight''': loaded['''output.weight'''], } else: __UpperCAmelCase = { '''model.norm.weight''': loaded[0]['''norm.weight'''], '''model.embed_tokens.weight''': torch.cat( [loaded[i]['''tok_embeddings.weight'''] for i in range(snake_case_ )] , dim=1 ), '''lm_head.weight''': torch.cat([loaded[i]['''output.weight'''] for i in range(snake_case_ )] , dim=0 ), } for k, v in state_dict.items(): __UpperCAmelCase = filename param_count += v.numel() torch.save(snake_case_ , os.path.join(snake_case_ , snake_case_ ) ) # Write configs __UpperCAmelCase = {'''total_size''': param_count * 2} write_json(snake_case_ , os.path.join(snake_case_ , '''pytorch_model.bin.index.json''' ) ) __UpperCAmelCase = params['''ffn_dim_multiplier'''] if '''ffn_dim_multiplier''' in params else 1 __UpperCAmelCase = params['''multiple_of'''] if '''multiple_of''' in params else 256 __UpperCAmelCase = LlamaConfig( hidden_size=snake_case_ , intermediate_size=compute_intermediate_size(snake_case_ , snake_case_ , snake_case_ ) , num_attention_heads=params['''n_heads'''] , num_hidden_layers=params['''n_layers'''] , rms_norm_eps=params['''norm_eps'''] , num_key_value_heads=snake_case_ , ) config.save_pretrained(snake_case_ ) # Make space so we can load the model properly now. del state_dict del loaded gc.collect() print('''Loading the checkpoint in a Llama model.''' ) __UpperCAmelCase = LlamaForCausalLM.from_pretrained(snake_case_ , torch_dtype=torch.floataa , low_cpu_mem_usage=snake_case_ ) # Avoid saving this as part of the config. del model.config._name_or_path print('''Saving in the Transformers format.''' ) model.save_pretrained(snake_case_ , safe_serialization=snake_case_ ) shutil.rmtree(snake_case_ ) def lowercase__ ( snake_case_ :Any , snake_case_ :List[Any] ): # Initialize the tokenizer based on the `spm` model __UpperCAmelCase = LlamaTokenizer if LlamaTokenizerFast is None else LlamaTokenizerFast print(F'''Saving a {tokenizer_class.__name__} to {tokenizer_path}.''' ) __UpperCAmelCase = tokenizer_class(snake_case_ ) tokenizer.save_pretrained(snake_case_ ) def lowercase__ ( ): __UpperCAmelCase = argparse.ArgumentParser() parser.add_argument( '''--input_dir''' , help='''Location of LLaMA weights, which contains tokenizer.model and model folders''' , ) parser.add_argument( '''--model_size''' , choices=['''7B''', '''7Bf''', '''13B''', '''13Bf''', '''30B''', '''65B''', '''70B''', '''70Bf''', '''tokenizer_only'''] , ) parser.add_argument( '''--output_dir''' , help='''Location to write HF model and tokenizer''' , ) parser.add_argument('''--safe_serialization''' , type=snake_case_ , help='''Whether or not to save using `safetensors`.''' ) __UpperCAmelCase = parser.parse_args() if args.model_size != "tokenizer_only": write_model( model_path=args.output_dir , input_base_path=os.path.join(args.input_dir , args.model_size ) , model_size=args.model_size , safe_serialization=args.safe_serialization , ) __UpperCAmelCase = os.path.join(args.input_dir , '''tokenizer.model''' ) write_tokenizer(args.output_dir , snake_case_ ) if __name__ == "__main__": main()
332
"""simple docstring""" import unittest from transformers import is_torch_available from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow if is_torch_available(): import torch from transformers import XLMRobertaModel @require_sentencepiece @require_tokenizers @require_torch class _UpperCAmelCase ( unittest.TestCase ): @slow def a ( self : str ): __UpperCAmelCase = XLMRobertaModel.from_pretrained('''xlm-roberta-base''' ) __UpperCAmelCase = torch.tensor([[0, 5_81, 1_02_69, 83, 9_99_42, 1_36, 6_07_42, 23, 70, 8_05_83, 1_82_76, 2]] ) # The dog is cute and lives in the garden house __UpperCAmelCase = torch.Size((1, 12, 7_68) ) # batch_size, sequence_length, embedding_vector_dim __UpperCAmelCase = torch.tensor( [[-0.0_101, 0.1_218, -0.0_803, 0.0_801, 0.1_327, 0.0_776, -0.1_215, 0.2_383, 0.3_338, 0.3_106, 0.0_300, 0.0_252]] ) # xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.base') # xlmr.eval() # expected_output_values_last_dim = xlmr.extract_features(input_ids[0])[:, :, -1] with torch.no_grad(): __UpperCAmelCase = model(_lowercase )['''last_hidden_state'''].detach() self.assertEqual(output.shape , _lowercase ) # compare the actual values for a slice of last dim self.assertTrue(torch.allclose(output[:, :, -1] , _lowercase , atol=1E-3 ) ) @slow def a ( self : str ): __UpperCAmelCase = XLMRobertaModel.from_pretrained('''xlm-roberta-large''' ) __UpperCAmelCase = torch.tensor([[0, 5_81, 1_02_69, 83, 9_99_42, 1_36, 6_07_42, 23, 70, 8_05_83, 1_82_76, 2]] ) # The dog is cute and lives in the garden house __UpperCAmelCase = torch.Size((1, 12, 10_24) ) # batch_size, sequence_length, embedding_vector_dim __UpperCAmelCase = torch.tensor( [[-0.0_699, -0.0_318, 0.0_705, -0.1_241, 0.0_999, -0.0_520, 0.1_004, -0.1_838, -0.4_704, 0.1_437, 0.0_821, 0.0_126]] ) # xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.large') # xlmr.eval() # expected_output_values_last_dim = xlmr.extract_features(input_ids[0])[:, :, -1] with torch.no_grad(): __UpperCAmelCase = model(_lowercase )['''last_hidden_state'''].detach() self.assertEqual(output.shape , _lowercase ) # compare the actual values for a slice of last dim self.assertTrue(torch.allclose(output[:, :, -1] , _lowercase , atol=1E-3 ) )
332
1
"""simple docstring""" import importlib.util import os import platform from argparse import ArgumentParser import huggingface_hub from .. import __version__ as version from ..utils import ( is_accelerate_available, is_flax_available, is_safetensors_available, is_tf_available, is_torch_available, ) from . import BaseTransformersCLICommand def lowercase__ ( snake_case_ :Optional[int] ): return EnvironmentCommand() def lowercase__ ( snake_case_ :List[str] ): return EnvironmentCommand(args.accelerate_config_file ) class _UpperCAmelCase ( _lowerCAmelCase ): @staticmethod def a ( _lowercase : ArgumentParser ): __UpperCAmelCase = parser.add_parser('''env''' ) download_parser.set_defaults(func=_lowercase ) download_parser.add_argument( '''--accelerate-config_file''' , default=_lowercase , help='''The accelerate config file to use for the default values in the launching script.''' , ) download_parser.set_defaults(func=_lowercase ) def __init__( self : Optional[int] , _lowercase : str , *_lowercase : Tuple ): __UpperCAmelCase = accelerate_config_file def a ( self : Dict ): __UpperCAmelCase = '''not installed''' if is_safetensors_available(): import safetensors __UpperCAmelCase = safetensors.__version__ elif importlib.util.find_spec('''safetensors''' ) is not None: import safetensors __UpperCAmelCase = F'''{safetensors.__version__} but is ignored because of PyTorch version too old.''' __UpperCAmelCase = '''not installed''' __UpperCAmelCase = __UpperCAmelCase = '''not found''' if is_accelerate_available(): import accelerate from accelerate.commands.config import default_config_file, load_config_from_file __UpperCAmelCase = accelerate.__version__ # Get the default from the config file. if self._accelerate_config_file is not None or os.path.isfile(_lowercase ): __UpperCAmelCase = load_config_from_file(self._accelerate_config_file ).to_dict() __UpperCAmelCase = ( '''\n'''.join([F'''\t- {prop}: {val}''' for prop, val in accelerate_config.items()] ) if isinstance(_lowercase , _lowercase ) else F'''\t{accelerate_config}''' ) __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''NA''' if is_torch_available(): import torch __UpperCAmelCase = torch.__version__ __UpperCAmelCase = torch.cuda.is_available() __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''NA''' if is_tf_available(): import tensorflow as tf __UpperCAmelCase = tf.__version__ try: # deprecated in v2.1 __UpperCAmelCase = tf.test.is_gpu_available() except AttributeError: # returns list of devices, convert to bool __UpperCAmelCase = bool(tf.config.list_physical_devices('''GPU''' ) ) __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''NA''' if is_flax_available(): import flax import jax import jaxlib __UpperCAmelCase = flax.__version__ __UpperCAmelCase = jax.__version__ __UpperCAmelCase = jaxlib.__version__ __UpperCAmelCase = jax.lib.xla_bridge.get_backend().platform __UpperCAmelCase = { '''`transformers` version''': version, '''Platform''': platform.platform(), '''Python version''': platform.python_version(), '''Huggingface_hub version''': huggingface_hub.__version__, '''Safetensors version''': F'''{safetensors_version}''', '''Accelerate version''': F'''{accelerate_version}''', '''Accelerate config''': F'''{accelerate_config_str}''', '''PyTorch version (GPU?)''': F'''{pt_version} ({pt_cuda_available})''', '''Tensorflow version (GPU?)''': F'''{tf_version} ({tf_cuda_available})''', '''Flax version (CPU?/GPU?/TPU?)''': F'''{flax_version} ({jax_backend})''', '''Jax version''': F'''{jax_version}''', '''JaxLib version''': F'''{jaxlib_version}''', '''Using GPU in script?''': '''<fill in>''', '''Using distributed or parallel set-up in script?''': '''<fill in>''', } print('''\nCopy-and-paste the text below in your GitHub issue and FILL OUT the two last points.\n''' ) print(self.format_dict(_lowercase ) ) return info @staticmethod def a ( _lowercase : str ): return "\n".join([F'''- {prop}: {val}''' for prop, val in d.items()] ) + "\n"
332
"""simple docstring""" def lowercase__ ( snake_case_ :Union[str, Any] ): # if the collection is empty, returns empty if collection == []: return [] # get some information about the collection __UpperCAmelCase = len(snake_case_ ) __UpperCAmelCase = max(snake_case_ ) __UpperCAmelCase = min(snake_case_ ) # create the counting array __UpperCAmelCase = coll_max + 1 - coll_min __UpperCAmelCase = [0] * counting_arr_length # count how much a number appears in the collection for number in collection: counting_arr[number - coll_min] += 1 # sum each position with it's predecessors. now, counting_arr[i] tells # us how many elements <= i has in the collection for i in range(1 , snake_case_ ): __UpperCAmelCase = counting_arr[i] + counting_arr[i - 1] # create the output collection __UpperCAmelCase = [0] * coll_len # place the elements in the output, respecting the original order (stable # sort) from end to begin, updating counting_arr for i in reversed(range(0 , snake_case_ ) ): __UpperCAmelCase = collection[i] counting_arr[collection[i] - coll_min] -= 1 return ordered def lowercase__ ( snake_case_ :str ): return "".join([chr(snake_case_ ) for i in counting_sort([ord(snake_case_ ) for c in string] )] ) if __name__ == "__main__": # Test string sort assert counting_sort_string('thisisthestring') == "eghhiiinrsssttt" _lowercase : int = input('Enter numbers separated by a comma:\n').strip() _lowercase : int = [int(item) for item in user_input.split(',')] print(counting_sort(unsorted))
332
1
"""simple docstring""" from __future__ import annotations from math import ceil, floor, sqrt def lowercase__ ( snake_case_ :int = 2_000_000 ): __UpperCAmelCase = [0] __UpperCAmelCase = 42 for idx in range(1 , ceil(sqrt(target * 2 ) * 1.1 ) ): triangle_numbers.append(triangle_numbers[-1] + idx ) # we want this to be as close as possible to target __UpperCAmelCase = 0 # the area corresponding to the grid that gives the product closest to target __UpperCAmelCase = 0 # an estimate of b, using the quadratic formula __UpperCAmelCase = 42 # the largest integer less than b_estimate __UpperCAmelCase = 42 # the largest integer less than b_estimate __UpperCAmelCase = 42 # the triangle number corresponding to b_floor __UpperCAmelCase = 42 # the triangle number corresponding to b_ceil __UpperCAmelCase = 42 for idx_a, triangle_a in enumerate(triangle_numbers[1:] , 1 ): __UpperCAmelCase = (-1 + sqrt(1 + 8 * target / triangle_a )) / 2 __UpperCAmelCase = floor(snake_case_ ) __UpperCAmelCase = ceil(snake_case_ ) __UpperCAmelCase = triangle_numbers[b_floor] __UpperCAmelCase = triangle_numbers[b_ceil] if abs(target - triangle_b_first_guess * triangle_a ) < abs( target - best_product ): __UpperCAmelCase = triangle_b_first_guess * triangle_a __UpperCAmelCase = idx_a * b_floor if abs(target - triangle_b_second_guess * triangle_a ) < abs( target - best_product ): __UpperCAmelCase = triangle_b_second_guess * triangle_a __UpperCAmelCase = idx_a * b_ceil return area if __name__ == "__main__": print(f"""{solution() = }""")
332
"""simple docstring""" from collections import defaultdict def lowercase__ ( snake_case_ :str , snake_case_ :str ): __UpperCAmelCase = first_str.lower().strip() __UpperCAmelCase = second_str.lower().strip() # Remove whitespace __UpperCAmelCase = first_str.replace(''' ''' , '''''' ) __UpperCAmelCase = second_str.replace(''' ''' , '''''' ) # Strings of different lengths are not anagrams if len(snake_case_ ) != len(snake_case_ ): return False # Default values for count should be 0 __UpperCAmelCase = defaultdict(snake_case_ ) # For each character in input strings, # increment count in the corresponding for i in range(len(snake_case_ ) ): 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() _lowercase : List[Any] = input('Enter the first string ').strip() _lowercase : Tuple = input('Enter the second string ').strip() _lowercase : str = check_anagrams(input_a, input_b) print(f"""{input_a} and {input_b} are {"" if status else "not "}anagrams.""")
332
1
"""simple docstring""" import shutil import tempfile import unittest from transformers import SPIECE_UNDERLINE, BatchEncoding, MBartaaTokenizer, MBartaaTokenizerFast, is_torch_available from transformers.testing_utils import ( get_tests_dir, nested_simplify, require_sentencepiece, require_tokenizers, require_torch, slow, ) from ...test_tokenization_common import TokenizerTesterMixin _lowercase : Tuple = get_tests_dir('fixtures/test_sentencepiece.model') if is_torch_available(): from transformers.models.mbart.modeling_mbart import shift_tokens_right _lowercase : List[str] = 25_00_04 _lowercase : int = 25_00_20 @require_sentencepiece @require_tokenizers class _UpperCAmelCase ( _lowerCAmelCase , unittest.TestCase ): a__ : Union[str, Any] = MBartaaTokenizer a__ : List[str] = MBartaaTokenizerFast a__ : Any = True a__ : List[str] = True def a ( self : str ): super().setUp() # We have a SentencePiece fixture for testing __UpperCAmelCase = MBartaaTokenizer(_lowercase , src_lang='''en_XX''' , tgt_lang='''ro_RO''' , keep_accents=_lowercase ) tokenizer.save_pretrained(self.tmpdirname ) def a ( self : Dict ): __UpperCAmelCase = '''<s>''' __UpperCAmelCase = 0 self.assertEqual(self.get_tokenizer()._convert_token_to_id(_lowercase ) , _lowercase ) self.assertEqual(self.get_tokenizer()._convert_id_to_token(_lowercase ) , _lowercase ) def a ( self : Optional[Any] ): __UpperCAmelCase = list(self.get_tokenizer().get_vocab().keys() ) self.assertEqual(vocab_keys[0] , '''<s>''' ) self.assertEqual(vocab_keys[1] , '''<pad>''' ) self.assertEqual(vocab_keys[-1] , '''<mask>''' ) self.assertEqual(len(_lowercase ) , 10_54 ) def a ( self : Tuple ): self.assertEqual(self.get_tokenizer().vocab_size , 10_54 ) def a ( self : str ): __UpperCAmelCase = MBartaaTokenizer(_lowercase , src_lang='''en_XX''' , tgt_lang='''ro_RO''' , keep_accents=_lowercase ) __UpperCAmelCase = tokenizer.tokenize('''This is a test''' ) self.assertListEqual(_lowercase , ['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est'''] ) self.assertListEqual( tokenizer.convert_tokens_to_ids(_lowercase ) , [value + tokenizer.fairseq_offset for value in [2_85, 46, 10, 1_70, 3_82]] , ) __UpperCAmelCase = tokenizer.tokenize('''I was born in 92000, and this is falsé.''' ) self.assertListEqual( _lowercase , [SPIECE_UNDERLINE + '''I''', SPIECE_UNDERLINE + '''was''', SPIECE_UNDERLINE + '''b''', '''or''', '''n''', SPIECE_UNDERLINE + '''in''', SPIECE_UNDERLINE + '''''', '''9''', '''2''', '''0''', '''0''', '''0''', ''',''', SPIECE_UNDERLINE + '''and''', SPIECE_UNDERLINE + '''this''', SPIECE_UNDERLINE + '''is''', SPIECE_UNDERLINE + '''f''', '''al''', '''s''', '''é''', '''.'''] , ) __UpperCAmelCase = tokenizer.convert_tokens_to_ids(_lowercase ) self.assertListEqual( _lowercase , [ value + tokenizer.fairseq_offset for value in [8, 21, 84, 55, 24, 19, 7, 2, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 2, 4] ] , ) __UpperCAmelCase = tokenizer.convert_ids_to_tokens(_lowercase ) self.assertListEqual( _lowercase , [SPIECE_UNDERLINE + '''I''', SPIECE_UNDERLINE + '''was''', SPIECE_UNDERLINE + '''b''', '''or''', '''n''', SPIECE_UNDERLINE + '''in''', SPIECE_UNDERLINE + '''''', '''<unk>''', '''2''', '''0''', '''0''', '''0''', ''',''', SPIECE_UNDERLINE + '''and''', SPIECE_UNDERLINE + '''this''', SPIECE_UNDERLINE + '''is''', SPIECE_UNDERLINE + '''f''', '''al''', '''s''', '''<unk>''', '''.'''] , ) @slow def a ( self : str ): # fmt: off __UpperCAmelCase = {'''input_ids''': [[25_00_04, 1_10_62, 8_27_72, 7, 15, 8_27_72, 5_38, 5_15_29, 2_37, 1_71_98, 12_90, 2_06, 9, 21_51_75, 13_14, 1_36, 1_71_98, 12_90, 2_06, 9, 5_63_59, 42, 12_20_09, 9, 1_64_66, 16, 8_73_44, 45_37, 9, 47_17, 7_83_81, 6, 15_99_58, 7, 15, 2_44_80, 6_18, 4, 5_27, 2_26_93, 54_28, 4, 27_77, 2_44_80, 98_74, 4, 4_35_23, 5_94, 4, 8_03, 1_83_92, 3_31_89, 18, 4, 4_35_23, 2_44_47, 1_23_99, 1_00, 2_49_55, 8_36_58, 96_26, 14_40_57, 15, 8_39, 2_23_35, 16, 1_36, 2_49_55, 8_36_58, 8_34_79, 15, 3_91_02, 7_24, 16, 6_78, 6_45, 27_89, 13_28, 45_89, 42, 12_20_09, 11_57_74, 23, 8_05, 13_28, 4_68_76, 7, 1_36, 5_38_94, 19_40, 4_22_27, 4_11_59, 1_77_21, 8_23, 4_25, 4, 2_75_12, 9_87_22, 2_06, 1_36, 55_31, 49_70, 9_19, 1_73_36, 5, 2], [25_00_04, 2_00_80, 6_18, 83, 8_27_75, 47, 4_79, 9, 15_17, 73, 5_38_94, 3_33, 8_05_81, 11_01_17, 1_88_11, 52_56, 12_95, 51, 15_25_26, 2_97, 79_86, 3_90, 12_44_16, 5_38, 3_54_31, 2_14, 98, 1_50_44, 2_57_37, 1_36, 71_08, 4_37_01, 23, 7_56, 13_53_55, 7, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [25_00_04, 5_81, 6_37_73, 11_94_55, 6, 14_77_97, 8_82_03, 7, 6_45, 70, 21, 32_85, 1_02_69, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], '''attention_mask''': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]} # noqa: E501 # fmt: on self.tokenizer_integration_test_util( expected_encoding=_lowercase , model_name='''facebook/mbart-large-50''' , revision='''d3913889c59cd5c9e456b269c376325eabad57e2''' , ) def a ( self : 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 __UpperCAmelCase = (self.rust_tokenizer_class, '''hf-internal-testing/tiny-random-mbart50''', {}) for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})''' ): __UpperCAmelCase = self.rust_tokenizer_class.from_pretrained(_lowercase , **_lowercase ) __UpperCAmelCase = self.tokenizer_class.from_pretrained(_lowercase , **_lowercase ) __UpperCAmelCase = tempfile.mkdtemp() __UpperCAmelCase = tokenizer_r.save_pretrained(_lowercase ) __UpperCAmelCase = tokenizer_p.save_pretrained(_lowercase ) # Checks it save with the same files + the tokenizer.json file for the fast one self.assertTrue(any('''tokenizer.json''' in f for f in tokenizer_r_files ) ) __UpperCAmelCase = tuple(f for f in tokenizer_r_files if '''tokenizer.json''' not in f ) self.assertSequenceEqual(_lowercase , _lowercase ) # Checks everything loads correctly in the same way __UpperCAmelCase = tokenizer_r.from_pretrained(_lowercase ) __UpperCAmelCase = tokenizer_p.from_pretrained(_lowercase ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(_lowercase , _lowercase ) ) # self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key)) # self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id")) shutil.rmtree(_lowercase ) # Save tokenizer rust, legacy_format=True __UpperCAmelCase = tempfile.mkdtemp() __UpperCAmelCase = tokenizer_r.save_pretrained(_lowercase , legacy_format=_lowercase ) __UpperCAmelCase = tokenizer_p.save_pretrained(_lowercase ) # Checks it save with the same files self.assertSequenceEqual(_lowercase , _lowercase ) # Checks everything loads correctly in the same way __UpperCAmelCase = tokenizer_r.from_pretrained(_lowercase ) __UpperCAmelCase = tokenizer_p.from_pretrained(_lowercase ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(_lowercase , _lowercase ) ) shutil.rmtree(_lowercase ) # Save tokenizer rust, legacy_format=False __UpperCAmelCase = tempfile.mkdtemp() __UpperCAmelCase = tokenizer_r.save_pretrained(_lowercase , legacy_format=_lowercase ) __UpperCAmelCase = tokenizer_p.save_pretrained(_lowercase ) # Checks it saved the tokenizer.json file self.assertTrue(any('''tokenizer.json''' in f for f in tokenizer_r_files ) ) # Checks everything loads correctly in the same way __UpperCAmelCase = tokenizer_r.from_pretrained(_lowercase ) __UpperCAmelCase = tokenizer_p.from_pretrained(_lowercase ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(_lowercase , _lowercase ) ) shutil.rmtree(_lowercase ) @require_torch @require_sentencepiece @require_tokenizers class _UpperCAmelCase ( unittest.TestCase ): a__ : str = "facebook/mbart-large-50-one-to-many-mmt" a__ : Union[str, Any] = [ " UN Chief Says There Is No Military Solution in Syria", " Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.", ] a__ : Any = [ "Şeful ONU declară că nu există o soluţie militară în Siria", "Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei" " pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor" " face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.", ] a__ : Any = [EN_CODE, 8_274, 127_873, 25_916, 7, 8_622, 2_071, 438, 67_485, 53, 187_895, 23, 51_712, 2] @classmethod def a ( cls : Tuple ): __UpperCAmelCase = MBartaaTokenizer.from_pretrained( cls.checkpoint_name , src_lang='''en_XX''' , tgt_lang='''ro_RO''' ) __UpperCAmelCase = 1 return cls def a ( self : Union[str, Any] ): self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ar_AR'''] , 25_00_01 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''en_EN'''] , 25_00_04 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ro_RO'''] , 25_00_20 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''mr_IN'''] , 25_00_38 ) def a ( self : Union[str, Any] ): __UpperCAmelCase = self.tokenizer.batch_encode_plus(self.src_text ).input_ids[0] self.assertListEqual(self.expected_src_tokens , _lowercase ) def a ( self : Optional[Any] ): self.assertIn(_lowercase , self.tokenizer.all_special_ids ) __UpperCAmelCase = [RO_CODE, 8_84, 90_19, 96, 9, 9_16, 8_67_92, 36, 1_87_43, 1_55_96, 5, 2] __UpperCAmelCase = self.tokenizer.decode(_lowercase , skip_special_tokens=_lowercase ) __UpperCAmelCase = self.tokenizer.decode(generated_ids[1:] , skip_special_tokens=_lowercase ) self.assertEqual(_lowercase , _lowercase ) self.assertNotIn(self.tokenizer.eos_token , _lowercase ) def a ( self : Optional[Any] ): __UpperCAmelCase = ['''this is gunna be a long sentence ''' * 20] assert isinstance(src_text[0] , _lowercase ) __UpperCAmelCase = 10 __UpperCAmelCase = self.tokenizer(_lowercase , max_length=_lowercase , truncation=_lowercase ).input_ids[0] self.assertEqual(ids[0] , _lowercase ) self.assertEqual(ids[-1] , 2 ) self.assertEqual(len(_lowercase ) , _lowercase ) def a ( self : Optional[int] ): self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['''<mask>''', '''ar_AR'''] ) , [25_00_53, 25_00_01] ) def a ( self : Union[str, Any] ): __UpperCAmelCase = tempfile.mkdtemp() __UpperCAmelCase = self.tokenizer.fairseq_tokens_to_ids self.tokenizer.save_pretrained(_lowercase ) __UpperCAmelCase = MBartaaTokenizer.from_pretrained(_lowercase ) self.assertDictEqual(new_tok.fairseq_tokens_to_ids , _lowercase ) @require_torch def a ( self : Dict ): __UpperCAmelCase = self.tokenizer(self.src_text , text_target=self.tgt_text , padding=_lowercase , return_tensors='''pt''' ) __UpperCAmelCase = shift_tokens_right(batch['''labels'''] , self.tokenizer.pad_token_id ) # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4 assert batch.input_ids[1][0] == EN_CODE assert batch.input_ids[1][-1] == 2 assert batch.labels[1][0] == RO_CODE assert batch.labels[1][-1] == 2 assert batch.decoder_input_ids[1][:2].tolist() == [2, RO_CODE] @require_torch def a ( self : Union[str, Any] ): __UpperCAmelCase = self.tokenizer( self.src_text , text_target=self.tgt_text , padding=_lowercase , truncation=_lowercase , max_length=len(self.expected_src_tokens ) , return_tensors='''pt''' , ) __UpperCAmelCase = shift_tokens_right(batch['''labels'''] , self.tokenizer.pad_token_id ) self.assertIsInstance(_lowercase , _lowercase ) self.assertEqual((2, 14) , batch.input_ids.shape ) self.assertEqual((2, 14) , batch.attention_mask.shape ) __UpperCAmelCase = batch.input_ids.tolist()[0] self.assertListEqual(self.expected_src_tokens , _lowercase ) self.assertEqual(2 , batch.decoder_input_ids[0, 0] ) # decoder_start_token_id # Test that special tokens are reset self.assertEqual(self.tokenizer.prefix_tokens , [EN_CODE] ) self.assertEqual(self.tokenizer.suffix_tokens , [self.tokenizer.eos_token_id] ) def a ( self : Union[str, Any] ): __UpperCAmelCase = self.tokenizer(self.src_text , padding=_lowercase , truncation=_lowercase , max_length=3 , return_tensors='''pt''' ) __UpperCAmelCase = self.tokenizer( text_target=self.tgt_text , padding=_lowercase , truncation=_lowercase , max_length=10 , return_tensors='''pt''' ) __UpperCAmelCase = targets['''input_ids'''] __UpperCAmelCase = shift_tokens_right(_lowercase , self.tokenizer.pad_token_id ) self.assertEqual(batch.input_ids.shape[1] , 3 ) self.assertEqual(batch.decoder_input_ids.shape[1] , 10 ) @require_torch def a ( self : Dict ): __UpperCAmelCase = self.tokenizer._build_translation_inputs( '''A test''' , return_tensors='''pt''' , src_lang='''en_XX''' , tgt_lang='''ar_AR''' ) self.assertEqual( nested_simplify(_lowercase ) , { # en_XX, A, test, EOS '''input_ids''': [[25_00_04, 62, 30_34, 2]], '''attention_mask''': [[1, 1, 1, 1]], # ar_AR '''forced_bos_token_id''': 25_00_01, } , )
332
"""simple docstring""" import os import tempfile import unittest from pathlib import Path from transformers import AutoConfig, is_torch_available from transformers.testing_utils import require_torch, torch_device if is_torch_available(): from transformers import PyTorchBenchmark, PyTorchBenchmarkArguments @require_torch class _UpperCAmelCase ( unittest.TestCase ): def a ( self : Dict , _lowercase : Union[str, Any] ): for model_result in results.values(): for batch_size, sequence_length in zip(model_result['''bs'''] , model_result['''ss'''] ): __UpperCAmelCase = model_result['''result'''][batch_size][sequence_length] self.assertIsNotNone(_lowercase ) def a ( self : str ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : List[str] ): __UpperCAmelCase = '''sgugger/tiny-distilbert-classification''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , only_pretrain_model=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : str ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , torchscript=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) @unittest.skipIf(torch_device == '''cpu''' , '''Cant do half precision''' ) def a ( self : Optional[Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , fpaa=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : int ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) # set architectures equal to `None` __UpperCAmelCase = None __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : Tuple ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) @unittest.skipIf(torch_device == '''cpu''' , '''Can\'t do half precision''' ) def a ( self : Optional[Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , fpaa=_lowercase , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) def a ( self : Any ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : str ): __UpperCAmelCase = '''sshleifer/tinier_bart''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_inference_result ) self.check_results_dict_not_empty(results.memory_inference_result ) def a ( self : Union[str, Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) def a ( self : int ): __UpperCAmelCase = '''sshleifer/tinier_bart''' __UpperCAmelCase = AutoConfig.from_pretrained(_lowercase ) __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase , configs=[config] ) __UpperCAmelCase = benchmark.run() self.check_results_dict_not_empty(results.time_train_result ) self.check_results_dict_not_empty(results.memory_train_result ) def a ( self : Optional[Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' with tempfile.TemporaryDirectory() as tmp_dir: __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , save_to_csv=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , inference_time_csv_file=os.path.join(_lowercase , '''inf_time.csv''' ) , train_memory_csv_file=os.path.join(_lowercase , '''train_mem.csv''' ) , inference_memory_csv_file=os.path.join(_lowercase , '''inf_mem.csv''' ) , train_time_csv_file=os.path.join(_lowercase , '''train_time.csv''' ) , env_info_csv_file=os.path.join(_lowercase , '''env.csv''' ) , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) benchmark.run() self.assertTrue(Path(os.path.join(_lowercase , '''inf_time.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(_lowercase , '''train_time.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(_lowercase , '''inf_mem.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(_lowercase , '''train_mem.csv''' ) ).exists() ) self.assertTrue(Path(os.path.join(_lowercase , '''env.csv''' ) ).exists() ) def a ( self : List[Any] ): __UpperCAmelCase = '''sshleifer/tiny-gpt2''' def _check_summary_is_not_empty(_lowercase : str ): self.assertTrue(hasattr(_lowercase , '''sequential''' ) ) self.assertTrue(hasattr(_lowercase , '''cumulative''' ) ) self.assertTrue(hasattr(_lowercase , '''current''' ) ) self.assertTrue(hasattr(_lowercase , '''total''' ) ) with tempfile.TemporaryDirectory() as tmp_dir: __UpperCAmelCase = PyTorchBenchmarkArguments( models=[MODEL_ID] , training=_lowercase , inference=_lowercase , sequence_lengths=[8] , batch_sizes=[1] , log_filename=os.path.join(_lowercase , '''log.txt''' ) , log_print=_lowercase , trace_memory_line_by_line=_lowercase , multi_process=_lowercase , ) __UpperCAmelCase = PyTorchBenchmark(_lowercase ) __UpperCAmelCase = benchmark.run() _check_summary_is_not_empty(result.inference_summary ) _check_summary_is_not_empty(result.train_summary ) self.assertTrue(Path(os.path.join(_lowercase , '''log.txt''' ) ).exists() )
332
1
"""simple docstring""" from __future__ import annotations import numpy as np from numpy import floataa from numpy.typing import NDArray def lowercase__ ( snake_case_ :NDArray[floataa] , snake_case_ :NDArray[floataa] , snake_case_ :list[int] , snake_case_ :int , ): __UpperCAmelCase , __UpperCAmelCase = coefficient_matrix.shape __UpperCAmelCase , __UpperCAmelCase = constant_matrix.shape if rowsa != colsa: __UpperCAmelCase = F'''Coefficient matrix dimensions must be nxn but received {rowsa}x{colsa}''' raise ValueError(snake_case_ ) if colsa != 1: __UpperCAmelCase = F'''Constant matrix must be nx1 but received {rowsa}x{colsa}''' raise ValueError(snake_case_ ) if rowsa != rowsa: __UpperCAmelCase = ( '''Coefficient and constant matrices dimensions must be nxn and nx1 but ''' F'''received {rowsa}x{colsa} and {rowsa}x{colsa}''' ) raise ValueError(snake_case_ ) if len(snake_case_ ) != rowsa: __UpperCAmelCase = ( '''Number of initial values must be equal to number of rows in coefficient ''' F'''matrix but received {len(snake_case_ )} and {rowsa}''' ) raise ValueError(snake_case_ ) if iterations <= 0: raise ValueError('''Iterations must be at least 1''' ) __UpperCAmelCase = np.concatenate( (coefficient_matrix, constant_matrix) , axis=1 ) __UpperCAmelCase , __UpperCAmelCase = table.shape strictly_diagonally_dominant(snake_case_ ) # Iterates the whole matrix for given number of times for _ in range(snake_case_ ): __UpperCAmelCase = [] for row in range(snake_case_ ): __UpperCAmelCase = 0 for col in range(snake_case_ ): if col == row: __UpperCAmelCase = table[row][col] elif col == cols - 1: __UpperCAmelCase = table[row][col] else: temp += (-1) * table[row][col] * init_val[col] __UpperCAmelCase = (temp + val) / denom new_val.append(snake_case_ ) __UpperCAmelCase = new_val return [float(snake_case_ ) for i in new_val] def lowercase__ ( snake_case_ :NDArray[floataa] ): __UpperCAmelCase , __UpperCAmelCase = table.shape __UpperCAmelCase = True for i in range(0 , snake_case_ ): __UpperCAmelCase = 0 for j in range(0 , cols - 1 ): if i == j: continue else: total += table[i][j] if table[i][i] <= total: raise ValueError('''Coefficient matrix is not strictly diagonally dominant''' ) return is_diagonally_dominant # Test Cases if __name__ == "__main__": import doctest doctest.testmod()
332
"""simple docstring""" from typing import Dict from .base import GenericTensor, Pipeline class _UpperCAmelCase ( _lowerCAmelCase ): def a ( self : Tuple , _lowercase : Dict=None , _lowercase : str=None , _lowercase : Union[str, Any]=None , **_lowercase : Tuple ): if tokenize_kwargs is None: __UpperCAmelCase = {} if truncation is not None: if "truncation" in tokenize_kwargs: raise ValueError( '''truncation parameter defined twice (given as keyword argument as well as in tokenize_kwargs)''' ) __UpperCAmelCase = truncation __UpperCAmelCase = tokenize_kwargs __UpperCAmelCase = {} if return_tensors is not None: __UpperCAmelCase = return_tensors return preprocess_params, {}, postprocess_params def a ( self : int , _lowercase : Optional[Any] , **_lowercase : Union[str, Any] ): __UpperCAmelCase = self.framework __UpperCAmelCase = self.tokenizer(_lowercase , return_tensors=_lowercase , **_lowercase ) return model_inputs def a ( self : List[str] , _lowercase : Tuple ): __UpperCAmelCase = self.model(**_lowercase ) return model_outputs def a ( self : int , _lowercase : Tuple , _lowercase : str=False ): # [0] is the first available tensor, logits or last_hidden_state. if return_tensors: return model_outputs[0] if self.framework == "pt": return model_outputs[0].tolist() elif self.framework == "tf": return model_outputs[0].numpy().tolist() def __call__( self : List[Any] , *_lowercase : Optional[Any] , **_lowercase : Union[str, Any] ): return super().__call__(*_lowercase , **_lowercase )
332
1
"""simple docstring""" import inspect import unittest from huggingface_hub import hf_hub_download from transformers import ConvNextConfig, UperNetConfig from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device from transformers.utils import is_torch_available, is_vision_available from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import UperNetForSemanticSegmentation from transformers.models.upernet.modeling_upernet import UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import AutoImageProcessor class _UpperCAmelCase : def __init__( self : str , _lowercase : List[str] , _lowercase : List[Any]=13 , _lowercase : Tuple=32 , _lowercase : Dict=3 , _lowercase : List[str]=4 , _lowercase : Optional[int]=[10, 20, 30, 40] , _lowercase : List[str]=[2, 2, 3, 2] , _lowercase : int=True , _lowercase : List[str]=True , _lowercase : Optional[Any]=37 , _lowercase : Tuple="gelu" , _lowercase : List[str]=10 , _lowercase : str=0.02 , _lowercase : Optional[Any]=["stage2", "stage3", "stage4"] , _lowercase : str=3 , _lowercase : List[str]=None , ): __UpperCAmelCase = parent __UpperCAmelCase = batch_size __UpperCAmelCase = image_size __UpperCAmelCase = num_channels __UpperCAmelCase = num_stages __UpperCAmelCase = hidden_sizes __UpperCAmelCase = depths __UpperCAmelCase = is_training __UpperCAmelCase = use_labels __UpperCAmelCase = intermediate_size __UpperCAmelCase = hidden_act __UpperCAmelCase = type_sequence_label_size __UpperCAmelCase = initializer_range __UpperCAmelCase = out_features __UpperCAmelCase = num_labels __UpperCAmelCase = scope __UpperCAmelCase = num_stages def a ( self : Optional[Any] ): __UpperCAmelCase = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) __UpperCAmelCase = None if self.use_labels: __UpperCAmelCase = ids_tensor([self.batch_size] , self.type_sequence_label_size ) __UpperCAmelCase = self.get_config() return config, pixel_values, labels def a ( self : Any ): return ConvNextConfig( num_channels=self.num_channels , num_stages=self.num_stages , hidden_sizes=self.hidden_sizes , depths=self.depths , is_training=self.is_training , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , out_features=self.out_features , ) def a ( self : int ): return UperNetConfig( backbone_config=self.get_backbone_config() , hidden_size=5_12 , pool_scales=[1, 2, 3, 6] , use_auxiliary_head=_lowercase , auxiliary_loss_weight=0.4 , auxiliary_in_channels=40 , auxiliary_channels=2_56 , auxiliary_num_convs=1 , auxiliary_concat_input=_lowercase , loss_ignore_index=2_55 , num_labels=self.num_labels , ) def a ( self : List[Any] , _lowercase : Union[str, Any] , _lowercase : Tuple , _lowercase : Tuple ): __UpperCAmelCase = UperNetForSemanticSegmentation(config=_lowercase ) model.to(_lowercase ) model.eval() __UpperCAmelCase = model(_lowercase ) self.parent.assertEqual( result.logits.shape , (self.batch_size, self.num_labels, self.image_size, self.image_size) ) def a ( self : str ): __UpperCAmelCase = self.prepare_config_and_inputs() ( ( __UpperCAmelCase ) , ( __UpperCAmelCase ) , ( __UpperCAmelCase ) , ) = config_and_inputs __UpperCAmelCase = {'''pixel_values''': pixel_values} return config, inputs_dict @require_torch class _UpperCAmelCase ( _lowerCAmelCase , _lowerCAmelCase , unittest.TestCase ): a__ : Dict = (UperNetForSemanticSegmentation,) if is_torch_available() else () a__ : Optional[int] = {"image-segmentation": UperNetForSemanticSegmentation} if is_torch_available() else {} a__ : Tuple = False a__ : Optional[int] = False a__ : str = False a__ : List[str] = False a__ : str = False a__ : Tuple = False def a ( self : Dict ): __UpperCAmelCase = UperNetModelTester(self ) __UpperCAmelCase = ConfigTester(self , config_class=_lowercase , has_text_modality=_lowercase , hidden_size=37 ) def a ( self : Union[str, Any] ): self.create_and_test_config_common_properties() self.config_tester.create_and_test_config_to_json_string() self.config_tester.create_and_test_config_to_json_file() self.config_tester.create_and_test_config_from_and_save_pretrained() self.config_tester.create_and_test_config_with_num_labels() self.config_tester.check_config_can_be_init_without_params() self.config_tester.check_config_arguments_init() def a ( self : List[Any] ): return def a ( self : str ): __UpperCAmelCase , __UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: __UpperCAmelCase = model_class(_lowercase ) __UpperCAmelCase = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic __UpperCAmelCase = [*signature.parameters.keys()] __UpperCAmelCase = ['''pixel_values'''] self.assertListEqual(arg_names[:1] , _lowercase ) def a ( self : Tuple ): __UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_semantic_segmentation(*_lowercase ) @unittest.skip(reason='''UperNet does not use inputs_embeds''' ) def a ( self : List[Any] ): pass @unittest.skip(reason='''UperNet does not support input and output embeddings''' ) def a ( self : int ): pass @unittest.skip(reason='''UperNet does not have a base model''' ) def a ( self : Optional[Any] ): pass @unittest.skip(reason='''UperNet does not have a base model''' ) def a ( self : List[Any] ): pass @require_torch_multi_gpu @unittest.skip(reason='''UperNet has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`''' ) def a ( self : List[Any] ): pass @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.''' ) def a ( self : str ): pass def a ( self : Union[str, Any] ): def check_hidden_states_output(_lowercase : Optional[int] , _lowercase : List[Any] , _lowercase : Dict ): __UpperCAmelCase = model_class(_lowercase ) model.to(_lowercase ) model.eval() with torch.no_grad(): __UpperCAmelCase = model(**self._prepare_for_class(_lowercase , _lowercase ) ) __UpperCAmelCase = outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states __UpperCAmelCase = self.model_tester.num_stages self.assertEqual(len(_lowercase ) , expected_num_stages + 1 ) # ConvNext's feature maps are of shape (batch_size, num_channels, height, width) self.assertListEqual( list(hidden_states[0].shape[-2:] ) , [self.model_tester.image_size // 4, self.model_tester.image_size // 4] , ) __UpperCAmelCase , __UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: __UpperCAmelCase = True check_hidden_states_output(_lowercase , _lowercase , _lowercase ) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] __UpperCAmelCase = True check_hidden_states_output(_lowercase , _lowercase , _lowercase ) def a ( self : List[str] ): __UpperCAmelCase , __UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() __UpperCAmelCase = _config_zero_init(_lowercase ) __UpperCAmelCase = _config_zero_init(configs_no_init.backbone_config ) for model_class in self.all_model_classes: __UpperCAmelCase = model_class(config=_lowercase ) for name, param in model.named_parameters(): if param.requires_grad: self.assertIn( ((param.data.mean() * 1E9).round() / 1E9).item() , [0.0, 1.0] , msg=F'''Parameter {name} of model {model_class} seems not properly initialized''' , ) @unittest.skip(reason='''UperNet does not have tied weights''' ) def a ( self : Union[str, Any] ): pass @slow def a ( self : Optional[Any] ): for model_name in UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: __UpperCAmelCase = UperNetForSemanticSegmentation.from_pretrained(_lowercase ) self.assertIsNotNone(_lowercase ) def lowercase__ ( ): __UpperCAmelCase = hf_hub_download( repo_id='''hf-internal-testing/fixtures_ade20k''' , repo_type='''dataset''' , filename='''ADE_val_00000001.jpg''' ) __UpperCAmelCase = Image.open(snake_case_ ).convert('''RGB''' ) return image @require_torch @require_vision @slow class _UpperCAmelCase ( unittest.TestCase ): def a ( self : List[Any] ): __UpperCAmelCase = AutoImageProcessor.from_pretrained('''openmmlab/upernet-swin-tiny''' ) __UpperCAmelCase = UperNetForSemanticSegmentation.from_pretrained('''openmmlab/upernet-swin-tiny''' ).to(_lowercase ) __UpperCAmelCase = prepare_img() __UpperCAmelCase = processor(images=_lowercase , return_tensors='''pt''' ).to(_lowercase ) with torch.no_grad(): __UpperCAmelCase = model(**_lowercase ) __UpperCAmelCase = torch.Size((1, model.config.num_labels, 5_12, 5_12) ) self.assertEqual(outputs.logits.shape , _lowercase ) __UpperCAmelCase = torch.tensor( [[-7.5_958, -7.5_958, -7.4_302], [-7.5_958, -7.5_958, -7.4_302], [-7.4_797, -7.4_797, -7.3_068]] ).to(_lowercase ) self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3] , _lowercase , atol=1E-4 ) ) def a ( self : List[str] ): __UpperCAmelCase = AutoImageProcessor.from_pretrained('''openmmlab/upernet-convnext-tiny''' ) __UpperCAmelCase = UperNetForSemanticSegmentation.from_pretrained('''openmmlab/upernet-convnext-tiny''' ).to(_lowercase ) __UpperCAmelCase = prepare_img() __UpperCAmelCase = processor(images=_lowercase , return_tensors='''pt''' ).to(_lowercase ) with torch.no_grad(): __UpperCAmelCase = model(**_lowercase ) __UpperCAmelCase = torch.Size((1, model.config.num_labels, 5_12, 5_12) ) self.assertEqual(outputs.logits.shape , _lowercase ) __UpperCAmelCase = torch.tensor( [[-8.8_110, -8.8_110, -8.6_521], [-8.8_110, -8.8_110, -8.6_521], [-8.7_746, -8.7_746, -8.6_130]] ).to(_lowercase ) self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3] , _lowercase , atol=1E-4 ) )
332
"""simple docstring""" from typing import List, Optional, Tuple, Union import PIL import torch from torchvision import transforms from diffusers.pipeline_utils import DiffusionPipeline, ImagePipelineOutput from diffusers.schedulers import DDIMScheduler from diffusers.utils import randn_tensor _lowercase : Union[str, Any] = transforms.Compose( [ transforms.Resize((2_56, 2_56)), transforms.ToTensor(), transforms.Normalize([0.5], [0.5]), ] ) def lowercase__ ( snake_case_ :List[Any] ): if isinstance(snake_case_ , torch.Tensor ): return image elif isinstance(snake_case_ , PIL.Image.Image ): __UpperCAmelCase = [image] __UpperCAmelCase = [trans(img.convert('''RGB''' ) ) for img in image] __UpperCAmelCase = torch.stack(snake_case_ ) return image class _UpperCAmelCase ( _lowerCAmelCase ): def __init__( self : Any , _lowercase : str , _lowercase : str ): super().__init__() # make sure scheduler can always be converted to DDIM __UpperCAmelCase = DDIMScheduler.from_config(scheduler.config ) self.register_modules(unet=_lowercase , scheduler=_lowercase ) def a ( self : int , _lowercase : List[str] ): if strength < 0 or strength > 1: raise ValueError(F'''The value of strength should in [0.0, 1.0] but is {strength}''' ) def a ( self : List[Any] , _lowercase : List[Any] , _lowercase : Optional[Any] , _lowercase : int ): # get the original timestep using init_timestep __UpperCAmelCase = min(int(num_inference_steps * strength ) , _lowercase ) __UpperCAmelCase = max(num_inference_steps - init_timestep , 0 ) __UpperCAmelCase = self.scheduler.timesteps[t_start:] return timesteps, num_inference_steps - t_start def a ( self : Optional[Any] , _lowercase : Union[str, Any] , _lowercase : Union[str, Any] , _lowercase : Optional[Any] , _lowercase : List[str] , _lowercase : Tuple , _lowercase : Optional[int]=None ): if not isinstance(_lowercase , (torch.Tensor, PIL.Image.Image, list) ): raise ValueError( F'''`image` has to be of type `torch.Tensor`, `PIL.Image.Image` or list but is {type(_lowercase )}''' ) __UpperCAmelCase = image.to(device=_lowercase , dtype=_lowercase ) 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.''' ) __UpperCAmelCase = init_latents.shape __UpperCAmelCase = randn_tensor(_lowercase , generator=_lowercase , device=_lowercase , dtype=_lowercase ) # get latents print('''add noise to latents at timestep''' , _lowercase ) __UpperCAmelCase = self.scheduler.add_noise(_lowercase , _lowercase , _lowercase ) __UpperCAmelCase = init_latents return latents @torch.no_grad() def __call__( self : Any , _lowercase : Union[torch.FloatTensor, PIL.Image.Image] = None , _lowercase : float = 0.8 , _lowercase : int = 1 , _lowercase : Optional[Union[torch.Generator, List[torch.Generator]]] = None , _lowercase : float = 0.0 , _lowercase : int = 50 , _lowercase : Optional[bool] = None , _lowercase : Optional[str] = "pil" , _lowercase : bool = True , ): self.check_inputs(_lowercase ) # 2. Preprocess image __UpperCAmelCase = preprocess(_lowercase ) # 3. set timesteps self.scheduler.set_timesteps(_lowercase , device=self.device ) __UpperCAmelCase , __UpperCAmelCase = self.get_timesteps(_lowercase , _lowercase , self.device ) __UpperCAmelCase = timesteps[:1].repeat(_lowercase ) # 4. Prepare latent variables __UpperCAmelCase = self.prepare_latents(_lowercase , _lowercase , _lowercase , self.unet.dtype , self.device , _lowercase ) __UpperCAmelCase = latents # 5. Denoising loop for t in self.progress_bar(_lowercase ): # 1. predict noise model_output __UpperCAmelCase = 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 __UpperCAmelCase = self.scheduler.step( _lowercase , _lowercase , _lowercase , eta=_lowercase , use_clipped_model_output=_lowercase , generator=_lowercase , ).prev_sample __UpperCAmelCase = (image / 2 + 0.5).clamp(0 , 1 ) __UpperCAmelCase = image.cpu().permute(0 , 2 , 3 , 1 ).numpy() if output_type == "pil": __UpperCAmelCase = self.numpy_to_pil(_lowercase ) if not return_dict: return (image, latent_timestep.item()) return ImagePipelineOutput(images=_lowercase )
332
1
"""simple docstring""" import argparse import json import requests import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import ConvNextConfig, SegformerImageProcessor, UperNetConfig, UperNetForSemanticSegmentation def lowercase__ ( snake_case_ :Optional[int] ): __UpperCAmelCase = 384 if "tiny" in model_name: __UpperCAmelCase = [3, 3, 9, 3] __UpperCAmelCase = [96, 192, 384, 768] if "small" in model_name: __UpperCAmelCase = [3, 3, 27, 3] __UpperCAmelCase = [96, 192, 384, 768] if "base" in model_name: __UpperCAmelCase = [3, 3, 27, 3] __UpperCAmelCase = [128, 256, 512, 1_024] __UpperCAmelCase = 512 if "large" in model_name: __UpperCAmelCase = [3, 3, 27, 3] __UpperCAmelCase = [192, 384, 768, 1_536] __UpperCAmelCase = 768 if "xlarge" in model_name: __UpperCAmelCase = [3, 3, 27, 3] __UpperCAmelCase = [256, 512, 1_024, 2_048] __UpperCAmelCase = 1_024 # set label information __UpperCAmelCase = 150 __UpperCAmelCase = '''huggingface/label-files''' __UpperCAmelCase = '''ade20k-id2label.json''' __UpperCAmelCase = json.load(open(hf_hub_download(snake_case_ , snake_case_ , repo_type='''dataset''' ) , '''r''' ) ) __UpperCAmelCase = {int(snake_case_ ): v for k, v in idalabel.items()} __UpperCAmelCase = {v: k for k, v in idalabel.items()} __UpperCAmelCase = ConvNextConfig( depths=snake_case_ , hidden_sizes=snake_case_ , out_features=['''stage1''', '''stage2''', '''stage3''', '''stage4'''] ) __UpperCAmelCase = UperNetConfig( backbone_config=snake_case_ , auxiliary_in_channels=snake_case_ , num_labels=snake_case_ , idalabel=snake_case_ , labelaid=snake_case_ , ) return config def lowercase__ ( snake_case_ :Any ): __UpperCAmelCase = [] # fmt: off # stem rename_keys.append(('''backbone.downsample_layers.0.0.weight''', '''backbone.embeddings.patch_embeddings.weight''') ) rename_keys.append(('''backbone.downsample_layers.0.0.bias''', '''backbone.embeddings.patch_embeddings.bias''') ) rename_keys.append(('''backbone.downsample_layers.0.1.weight''', '''backbone.embeddings.layernorm.weight''') ) rename_keys.append(('''backbone.downsample_layers.0.1.bias''', '''backbone.embeddings.layernorm.bias''') ) # stages for i in range(len(config.backbone_config.depths ) ): for j in range(config.backbone_config.depths[i] ): rename_keys.append((F'''backbone.stages.{i}.{j}.gamma''', F'''backbone.encoder.stages.{i}.layers.{j}.layer_scale_parameter''') ) rename_keys.append((F'''backbone.stages.{i}.{j}.depthwise_conv.weight''', F'''backbone.encoder.stages.{i}.layers.{j}.dwconv.weight''') ) rename_keys.append((F'''backbone.stages.{i}.{j}.depthwise_conv.bias''', F'''backbone.encoder.stages.{i}.layers.{j}.dwconv.bias''') ) rename_keys.append((F'''backbone.stages.{i}.{j}.norm.weight''', F'''backbone.encoder.stages.{i}.layers.{j}.layernorm.weight''') ) rename_keys.append((F'''backbone.stages.{i}.{j}.norm.bias''', F'''backbone.encoder.stages.{i}.layers.{j}.layernorm.bias''') ) rename_keys.append((F'''backbone.stages.{i}.{j}.pointwise_conv1.weight''', F'''backbone.encoder.stages.{i}.layers.{j}.pwconv1.weight''') ) rename_keys.append((F'''backbone.stages.{i}.{j}.pointwise_conv1.bias''', F'''backbone.encoder.stages.{i}.layers.{j}.pwconv1.bias''') ) rename_keys.append((F'''backbone.stages.{i}.{j}.pointwise_conv2.weight''', F'''backbone.encoder.stages.{i}.layers.{j}.pwconv2.weight''') ) rename_keys.append((F'''backbone.stages.{i}.{j}.pointwise_conv2.bias''', F'''backbone.encoder.stages.{i}.layers.{j}.pwconv2.bias''') ) if i > 0: rename_keys.append((F'''backbone.downsample_layers.{i}.0.weight''', F'''backbone.encoder.stages.{i}.downsampling_layer.0.weight''') ) rename_keys.append((F'''backbone.downsample_layers.{i}.0.bias''', F'''backbone.encoder.stages.{i}.downsampling_layer.0.bias''') ) rename_keys.append((F'''backbone.downsample_layers.{i}.1.weight''', F'''backbone.encoder.stages.{i}.downsampling_layer.1.weight''') ) rename_keys.append((F'''backbone.downsample_layers.{i}.1.bias''', F'''backbone.encoder.stages.{i}.downsampling_layer.1.bias''') ) rename_keys.append((F'''backbone.norm{i}.weight''', F'''backbone.hidden_states_norms.stage{i+1}.weight''') ) rename_keys.append((F'''backbone.norm{i}.bias''', F'''backbone.hidden_states_norms.stage{i+1}.bias''') ) # decode head rename_keys.extend( [ ('''decode_head.conv_seg.weight''', '''decode_head.classifier.weight'''), ('''decode_head.conv_seg.bias''', '''decode_head.classifier.bias'''), ('''auxiliary_head.conv_seg.weight''', '''auxiliary_head.classifier.weight'''), ('''auxiliary_head.conv_seg.bias''', '''auxiliary_head.classifier.bias'''), ] ) # fmt: on return rename_keys def lowercase__ ( snake_case_ :List[str] , snake_case_ :List[Any] , snake_case_ :Any ): __UpperCAmelCase = dct.pop(snake_case_ ) __UpperCAmelCase = val def lowercase__ ( snake_case_ :int , snake_case_ :List[str] , snake_case_ :Optional[Any] ): __UpperCAmelCase = { '''upernet-convnext-tiny''': '''https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_tiny_fp16_512x512_160k_ade20k/upernet_convnext_tiny_fp16_512x512_160k_ade20k_20220227_124553-cad485de.pth''', '''upernet-convnext-small''': '''https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_small_fp16_512x512_160k_ade20k/upernet_convnext_small_fp16_512x512_160k_ade20k_20220227_131208-1b1e394f.pth''', '''upernet-convnext-base''': '''https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_base_fp16_512x512_160k_ade20k/upernet_convnext_base_fp16_512x512_160k_ade20k_20220227_181227-02a24fc6.pth''', '''upernet-convnext-large''': '''https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_large_fp16_640x640_160k_ade20k/upernet_convnext_large_fp16_640x640_160k_ade20k_20220226_040532-e57aa54d.pth''', '''upernet-convnext-xlarge''': '''https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_xlarge_fp16_640x640_160k_ade20k/upernet_convnext_xlarge_fp16_640x640_160k_ade20k_20220226_080344-95fc38c2.pth''', } __UpperCAmelCase = model_name_to_url[model_name] __UpperCAmelCase = torch.hub.load_state_dict_from_url(snake_case_ , map_location='''cpu''' )['''state_dict'''] __UpperCAmelCase = get_upernet_config(snake_case_ ) __UpperCAmelCase = UperNetForSemanticSegmentation(snake_case_ ) model.eval() # replace "bn" => "batch_norm" for key in state_dict.copy().keys(): __UpperCAmelCase = state_dict.pop(snake_case_ ) if "bn" in key: __UpperCAmelCase = key.replace('''bn''' , '''batch_norm''' ) __UpperCAmelCase = val # rename keys __UpperCAmelCase = create_rename_keys(snake_case_ ) for src, dest in rename_keys: rename_key(snake_case_ , snake_case_ , snake_case_ ) model.load_state_dict(snake_case_ ) # verify on image __UpperCAmelCase = '''https://huggingface.co/datasets/hf-internal-testing/fixtures_ade20k/resolve/main/ADE_val_00000001.jpg''' __UpperCAmelCase = Image.open(requests.get(snake_case_ , stream=snake_case_ ).raw ).convert('''RGB''' ) __UpperCAmelCase = SegformerImageProcessor() __UpperCAmelCase = processor(snake_case_ , return_tensors='''pt''' ).pixel_values with torch.no_grad(): __UpperCAmelCase = model(snake_case_ ) if model_name == "upernet-convnext-tiny": __UpperCAmelCase = torch.tensor( [[-8.8110, -8.8110, -8.6521], [-8.8110, -8.8110, -8.6521], [-8.7746, -8.7746, -8.6130]] ) elif model_name == "upernet-convnext-small": __UpperCAmelCase = torch.tensor( [[-8.8236, -8.8236, -8.6771], [-8.8236, -8.8236, -8.6771], [-8.7638, -8.7638, -8.6240]] ) elif model_name == "upernet-convnext-base": __UpperCAmelCase = torch.tensor( [[-8.8558, -8.8558, -8.6905], [-8.8558, -8.8558, -8.6905], [-8.7669, -8.7669, -8.6021]] ) elif model_name == "upernet-convnext-large": __UpperCAmelCase = torch.tensor( [[-8.6660, -8.6660, -8.6210], [-8.6660, -8.6660, -8.6210], [-8.6310, -8.6310, -8.5964]] ) elif model_name == "upernet-convnext-xlarge": __UpperCAmelCase = torch.tensor( [[-8.4980, -8.4980, -8.3977], [-8.4980, -8.4980, -8.3977], [-8.4379, -8.4379, -8.3412]] ) print('''Logits:''' , outputs.logits[0, 0, :3, :3] ) assert torch.allclose(outputs.logits[0, 0, :3, :3] , snake_case_ , atol=1E-4 ) print('''Looks ok!''' ) if pytorch_dump_folder_path is not None: print(F'''Saving model {model_name} to {pytorch_dump_folder_path}''' ) model.save_pretrained(snake_case_ ) print(F'''Saving processor to {pytorch_dump_folder_path}''' ) processor.save_pretrained(snake_case_ ) if push_to_hub: print(F'''Pushing model and processor for {model_name} to hub''' ) model.push_to_hub(F'''openmmlab/{model_name}''' ) processor.push_to_hub(F'''openmmlab/{model_name}''' ) if __name__ == "__main__": _lowercase : int = argparse.ArgumentParser() # Required parameters parser.add_argument( '--model_name', default='upernet-convnext-tiny', type=str, choices=[f"""upernet-convnext-{size}""" for size in ['tiny', 'small', 'base', 'large', 'xlarge']], help='Name of the ConvNext UperNet model you\'d like to convert.', ) parser.add_argument( '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.' ) parser.add_argument( '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.' ) _lowercase : List[Any] = parser.parse_args() convert_upernet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
332
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, ) _lowercase : Union[str, Any] = { 'configuration_resnet': ['RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ResNetConfig', 'ResNetOnnxConfig'] } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : int = [ 'RESNET_PRETRAINED_MODEL_ARCHIVE_LIST', 'ResNetForImageClassification', 'ResNetModel', 'ResNetPreTrainedModel', 'ResNetBackbone', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : Union[str, Any] = [ 'TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST', 'TFResNetForImageClassification', 'TFResNetModel', 'TFResNetPreTrainedModel', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase : Optional[int] = [ '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 _lowercase : Dict = _LazyModule(__name__, globals()['__file__'], _import_structure)
332
1
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import _LazyModule _lowercase : int = {'processing_wav2vec2_with_lm': ['Wav2Vec2ProcessorWithLM']} if TYPE_CHECKING: from .processing_wavaveca_with_lm import WavaVecaProcessorWithLM else: import sys _lowercase : Union[str, Any] = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
332
"""simple docstring""" _lowercase : Any = '\n# Installazione di Transformers\n! pip install transformers datasets\n# Per installare dalla fonte invece dell\'ultima versione rilasciata, commenta il comando sopra e\n# rimuovi la modalità commento al comando seguente.\n# ! pip install git+https://github.com/huggingface/transformers.git\n' _lowercase : Tuple = [{'type': 'code', 'content': INSTALL_CONTENT}] _lowercase : int = { '{processor_class}': 'FakeProcessorClass', '{model_class}': 'FakeModelClass', '{object_class}': 'FakeObjectClass', }
332
1
"""simple docstring""" import math import unittest def lowercase__ ( snake_case_ :int ): assert isinstance(snake_case_ , snake_case_ ) and ( number >= 0 ), "'number' must been an int and positive" if 1 < number < 4: # 2 and 3 are primes return True elif number < 2 or number % 2 == 0 or number % 3 == 0: # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes return False # All primes number are in format of 6k +/- 1 for i in range(5 , int(math.sqrt(snake_case_ ) + 1 ) , 6 ): if number % i == 0 or number % (i + 2) == 0: return False return True class _UpperCAmelCase ( unittest.TestCase ): def a ( self : int ): self.assertTrue(is_prime(2 ) ) self.assertTrue(is_prime(3 ) ) self.assertTrue(is_prime(5 ) ) self.assertTrue(is_prime(7 ) ) self.assertTrue(is_prime(11 ) ) self.assertTrue(is_prime(13 ) ) self.assertTrue(is_prime(17 ) ) self.assertTrue(is_prime(19 ) ) self.assertTrue(is_prime(23 ) ) self.assertTrue(is_prime(29 ) ) def a ( self : List[Any] ): with self.assertRaises(_lowercase ): is_prime(-19 ) self.assertFalse( is_prime(0 ) , '''Zero doesn\'t have any positive factors, primes must have exactly two.''' , ) self.assertFalse( is_prime(1 ) , '''One only has 1 positive factor, primes must have exactly two.''' , ) self.assertFalse(is_prime(2 * 2 ) ) self.assertFalse(is_prime(2 * 3 ) ) self.assertFalse(is_prime(3 * 3 ) ) self.assertFalse(is_prime(3 * 5 ) ) self.assertFalse(is_prime(3 * 5 * 7 ) ) if __name__ == "__main__": unittest.main()
332
"""simple docstring""" import importlib.util import os import platform from argparse import ArgumentParser import huggingface_hub from .. import __version__ as version from ..utils import ( is_accelerate_available, is_flax_available, is_safetensors_available, is_tf_available, is_torch_available, ) from . import BaseTransformersCLICommand def lowercase__ ( snake_case_ :Optional[int] ): return EnvironmentCommand() def lowercase__ ( snake_case_ :List[str] ): return EnvironmentCommand(args.accelerate_config_file ) class _UpperCAmelCase ( _lowerCAmelCase ): @staticmethod def a ( _lowercase : ArgumentParser ): __UpperCAmelCase = parser.add_parser('''env''' ) download_parser.set_defaults(func=_lowercase ) download_parser.add_argument( '''--accelerate-config_file''' , default=_lowercase , help='''The accelerate config file to use for the default values in the launching script.''' , ) download_parser.set_defaults(func=_lowercase ) def __init__( self : Optional[int] , _lowercase : str , *_lowercase : Tuple ): __UpperCAmelCase = accelerate_config_file def a ( self : Dict ): __UpperCAmelCase = '''not installed''' if is_safetensors_available(): import safetensors __UpperCAmelCase = safetensors.__version__ elif importlib.util.find_spec('''safetensors''' ) is not None: import safetensors __UpperCAmelCase = F'''{safetensors.__version__} but is ignored because of PyTorch version too old.''' __UpperCAmelCase = '''not installed''' __UpperCAmelCase = __UpperCAmelCase = '''not found''' if is_accelerate_available(): import accelerate from accelerate.commands.config import default_config_file, load_config_from_file __UpperCAmelCase = accelerate.__version__ # Get the default from the config file. if self._accelerate_config_file is not None or os.path.isfile(_lowercase ): __UpperCAmelCase = load_config_from_file(self._accelerate_config_file ).to_dict() __UpperCAmelCase = ( '''\n'''.join([F'''\t- {prop}: {val}''' for prop, val in accelerate_config.items()] ) if isinstance(_lowercase , _lowercase ) else F'''\t{accelerate_config}''' ) __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''NA''' if is_torch_available(): import torch __UpperCAmelCase = torch.__version__ __UpperCAmelCase = torch.cuda.is_available() __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''NA''' if is_tf_available(): import tensorflow as tf __UpperCAmelCase = tf.__version__ try: # deprecated in v2.1 __UpperCAmelCase = tf.test.is_gpu_available() except AttributeError: # returns list of devices, convert to bool __UpperCAmelCase = bool(tf.config.list_physical_devices('''GPU''' ) ) __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''not installed''' __UpperCAmelCase = '''NA''' if is_flax_available(): import flax import jax import jaxlib __UpperCAmelCase = flax.__version__ __UpperCAmelCase = jax.__version__ __UpperCAmelCase = jaxlib.__version__ __UpperCAmelCase = jax.lib.xla_bridge.get_backend().platform __UpperCAmelCase = { '''`transformers` version''': version, '''Platform''': platform.platform(), '''Python version''': platform.python_version(), '''Huggingface_hub version''': huggingface_hub.__version__, '''Safetensors version''': F'''{safetensors_version}''', '''Accelerate version''': F'''{accelerate_version}''', '''Accelerate config''': F'''{accelerate_config_str}''', '''PyTorch version (GPU?)''': F'''{pt_version} ({pt_cuda_available})''', '''Tensorflow version (GPU?)''': F'''{tf_version} ({tf_cuda_available})''', '''Flax version (CPU?/GPU?/TPU?)''': F'''{flax_version} ({jax_backend})''', '''Jax version''': F'''{jax_version}''', '''JaxLib version''': F'''{jaxlib_version}''', '''Using GPU in script?''': '''<fill in>''', '''Using distributed or parallel set-up in script?''': '''<fill in>''', } print('''\nCopy-and-paste the text below in your GitHub issue and FILL OUT the two last points.\n''' ) print(self.format_dict(_lowercase ) ) return info @staticmethod def a ( _lowercase : str ): return "\n".join([F'''- {prop}: {val}''' for prop, val in d.items()] ) + "\n"
332
1
"""simple docstring""" import warnings from ...utils import logging from .image_processing_donut import DonutImageProcessor _lowercase : List[str] = logging.get_logger(__name__) class _UpperCAmelCase ( _lowerCAmelCase ): def __init__( self : Any , *_lowercase : List[Any] , **_lowercase : Dict ): warnings.warn( '''The class DonutFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please''' ''' use DonutImageProcessor instead.''' , _lowercase , ) super().__init__(*_lowercase , **_lowercase )
332
"""simple docstring""" from __future__ import annotations def lowercase__ ( snake_case_ :list[float] , snake_case_ :list[float] ): __UpperCAmelCase = sorted(numsa + numsa ) __UpperCAmelCase , __UpperCAmelCase = divmod(len(snake_case_ ) , 2 ) if mod == 1: return all_numbers[div] else: return (all_numbers[div] + all_numbers[div - 1]) / 2 if __name__ == "__main__": import doctest doctest.testmod() _lowercase : int = [float(x) for x in input('Enter the elements of first array: ').split()] _lowercase : Tuple = [float(x) for x in input('Enter the elements of second array: ').split()] print(f"""The median of two arrays is: {median_of_two_arrays(array_a, array_a)}""")
332
1